/.../
        $originalFileName = pathinfo($csvFile->getClientOriginalName(), PATHINFO_FILENAME);                  
        $safeFileName = $slugger->slug($originalFileName);              
        $newFileName = $safeFileName.'-'.uniqid().'.'.$csvFile->guessExtension();        
        $csvFile->move($fileDirectory, $newFileName);                    
        $upload->setCsvFile($newFileName);                   
        $manager->persist($upload);
        $csv = Reader::createFromPath($fileDirectory.$newFileName);                    
        $csv->setHeaderOffset(0);
        $csv->setDelimiter(';');
        $csv->setEscape('');
        $records = $csv->getRecords();   
 
        foreach ($records as $record) {
            $numero = $record["Identifiant de la fiche"];
            $date = $record["Date d'emission de la fiche"];
            $origine = $record['Cas origine'];
            $cloture = $record['Cas cloture'];
            $commentaire = $record['Commentaire'];
            $epidemi = $record['Type de cas'];          
            $score = $record['Score'];   
 
            $infection = $manager->getRepository(Infection::class)->findOneBy(['infection' => mb_convert_encoding($record['Type infection'], 'UTF-8', 'Windows-1252')]);
            $structure = $manager->getRepository(Structure::class)->findOneBy(['nom' => mb_convert_encoding($record['Nom de la structure'], 'UTF-8', 'Windows-1252')]);
 
            $commentaire = mb_convert_encoding($commentaire, 'UTF-8', 'Windows-1252');
            $epidemi = mb_convert_encoding($epidemi, 'UTF-8', 'Windows-1252');
 
 
            //verification du numero de la fiche et utilisation pour empecher upload de doublon
            if(!(is_numeric($numero)) || (strlen($numero) !== 5)){
                $this->addFlash('error','Problème de donnée dans le champs "Identifiant de la fiche"');
                return $this->redirectToRoute('signalement.upload');  
            }
            $signal = $manager->getRepository(Signalement::class)->findOneBy(['numero' => $numero]);
            if(is_null($signal)){
                $signal = (new Signalement())->setNumero($numero);
                $manager->persist($signal);
            }
 
            //verification de la date
            [$d, $m, $y] = explode('/',$date);
            if(!checkdate($m, $d, $y)){
                $this->addFlash('error','Problème de donnée dans le champ "date d\'émission"');
                return $this->redirectToRoute('signalement.upload');  
            }
            $dbdate = \DateTimeImmutable::createFromFormat('d/m/Y', $date);
 
            //verification que les champs cas origine et cas cloture soient bien numeric
            if(!(is_numeric($origine)) ||  !(is_numeric($cloture))){
                $this->addFlash('error','Problème de donnée dans un des champs "Cas origine" et/ou "Cas cloture"');
                return $this->redirectToRoute('signalement.upload');  
            }        
            //si cas origine est supérieur à cas cloture
            if($origine > $cloture){
                $this->addFlash('error','Problème de donnée dans un des champs "Cas origine / Cas cloture" le cas d\'origine ne peut pas être supérieur au cas cloture');
                return $this->redirectToRoute('signalement.upload');  
            }
 
            //si le champ commentaire est vide
            if(empty($commentaire)){
                $this->addFlash('error','Problème de donnée dans le champ "commentaire", celui-ci ne peut pas être vide');
                return $this->redirectToRoute('signalement.upload');  
            }
 
            //si le champ Type de cas est valide avec verification type de cas/cas cloture
            if(($epidemi !== "Épidémie") && ($epidemi !== "Cas isolé")){
                $this->addFlash('error','Problème de donnée dans le champ "Type de cas" en ligne(s) : '. $counter);
                return $this->redirectToRoute('signalement.upload');  
            }else if(($epidemi !== "Épidémie") && ($cloture > 1)){
                $this->addFlash('error','Le type de cas ne peut pas être "Cas Isolé" si le nombre de cas cloture est > 1');
                return $this->redirectToRoute('signalement.upload');
            }else if(($epidemi !== "Cas isolé") && ($cloture == 1)){
                $this->addFlash('error','Le type de cas ne peut pas être "Épidémie" si le nombre de cas cloture est = 1');
 
            //si le champ Score est valide 
            if(empty($score) || !is_numeric($score) || strlen($score) > 4 || $score > 212){
                $this->addFlash('error','Problème de donnée dans le champ "Score"');
                return $this->redirectToRoute('signalement.upload');  
            }
 
            //si le champ Type infection est valide
            if(!(ctype_alpha($infection)) && empty($infection)){
                $this->addFlash('error','Problème de donnée dans le champ "Type infection"');
                return $this->redirectToRoute('signalement.upload');  
            }
 
            //si le champ Structure est valide
            if(!(ctype_alpha($structure)) && empty($structure)){
                $this->addFlash('error','Problème de donnée dans le champ "Structure"');
                return $this->redirectToRoute('signalement.upload');  
            }  
 
            $signal              
                ->setDate($dbdate)
                ->setCasO($origine)
                ->setCasC($cloture)
                ->setCommentaire($commentaire)
                ->setEpidemie($epidemi)
                ->setCapacite($capacite)              
                ->setScore($score)      
                ->setInfection($infection) 
                ->setStructure($structure)
                ;
        }
/.../
 
 
                return $this->redirectToRoute('signalement.upload');
            }

        function test(string $truc): string
        {
            return "le type est : $truc";
        }

 
    #[Route('/signalement/upload', name: 'signalement.upload', methods:['GET', 'POST'])]
    public function upload(
        Request $request,
        SluggerInterface $slugger,
         #[Autowire('%kernel.project_dir%/public/uploads/')] string $fileDirectory
    )  : Response {
            $upload = new Upload();
            $form = $this->createForm(ImportType::class, $upload);
            $form->handleRequest($request);
            if ($form->isSubmitted() && $form->isValid()) {
                $file = $form -> get('csvFile')->getData();
                if($file){
                    $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
                    $safeFileName = $slugger->slug($fileName);
                    $newFileName = $safeFileName.'-'.uniqid().'.'.$file->guessExtension();
                    $upload->setCsvFile($newFileName);
                    $csv = Reader::createFromPath('%kernel.root.dir%/../public/uploads/'.$fileName);
                    $csv->setHeaderOffset(0);
                    $csv->setDelimiter(';');
                    $csv->setEscape('');
                    $records = $csv->getRecords();
                    foreach ($records as $record){ 
                        $signalement = (new Signalement())
                            ->setNumero($record['Identifiant de la fiche'])
                            //etc..
                            ;
                            $this->em->persist($signalement);
                    }                    
                }
                $this->em->flush();
                    $this->addFlash('success','Bien ajouté avec succès');
                    return $this->redirectToRoute('signalement.index');
            }
        return $this->render('pages/signalement/upload.html.twig',
            ['form' => $form,]);
    }

 
Controller "App\Controller\SignalementController::upload" requires the "$fileDirectory" argument that could not be resolved. Either the argument is nullable and no null value has been provided, no default value has been provided or there is a non-optional argument after this one.

 
`%kernel.root.dir%/../public/uploads/test`: failed to open stream: No such file or directory.

controllers:
    resource: '../src/Controller/'
    type: attribute
    prefix: /{_locale}
    requirements:
        _locale: '%app_locales%'
    defaults:
        _locale: '%locale%'
 
site:
    resource: 'routes/routes_site.yaml'
    prefix:   /{_locale}
    requirements:
        _locale: '%app_locales%'
    defaults:
        _locale: '%locale%'

visit_ajax_post:
    path:      /visit_ajax_post
    defaults:
        _controller: App\Controller\VisitController::visit_ajax_action

$(document).ready(function () {
    var nom;
    $.ajax({
        type: "POST",
        url: "{{ path('visit_ajax_post') }}",
        contentType: "application/json; charset=utf-8",
        dataType: 'json',
        async: false,
        data: {id: 'toto'},
        success: function(data) {
                alert(data);
                nom = data.idreservation;
        },
        error: function () {
            alert('erreur visit');
        }
    });
    alert(nom);
});

public function visit_ajax_action(Request $request): jsonResponse
{
	if($request->isXmlHttpRequest()) {
		$idReservation = $request->request->get('id');
		$reponse = new JsonResponse([
			'data' => array('idreservation' => $idReservation)
		]);
		return $reponse;
	}
	return new Response("Ce n'est pas une requête Ajax");
}

 
<?php
namespace App\Command;
use App\Entity\Structure;
use DateTimeImmutable;
use League\Csv\Reader;
use App\Entity\Signalement;
use League\Csv\Statement;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
 
class ImportCSVCommand extends Command {
    private $em;    
    public function __construct(EntityManagerInterface $em) {
        parent::__construct();
        $this->em = $em;
    }
 
    protected function configure(): void {
        $this
            ->setName('csv:import')
            ->setDescription("Import CSV in DB") ;
    }
 
    protected function execute(InputInterface $input,OutputInterface $output): int {
        $io = new SymfonyStyle($input, $output);
        $io->title('Import CSV ...');
        $csv = Reader::from('src/Data/listedeproduit.csv', 'r');
        $csv->setHeaderOffset(0);
        $csv->setDelimiter(';');
        $csv->setEscape('');
        $records = $csv->getRecords();
 
        foreach ($records as $record){          
            $structure = (new Structure())
                 ->setNom($record['Nom de la structure']);           
 
            $signalement = (new Signalement())
                ->setNumero($record['Identifiant de la fiche'])                
                ->setStructure($structure) ;
                //etc...
 
            $this->em->persist($signalement);
 
        }
        $this->em->flush();                
        $io->success('Great CSV in DB !');
        return Command::SUCCESS;
    }    
}

 
 A new entity was found through the relationship 'App\Entity\Signalement#structure' that was not configured to cascade persist   
   operations for entity: 9. To solve this issue: Either explicitly call EntityManager#persist() on this unknown entity or configure cascade persist this association in the mapping for example @ManyToOne(..,cascade={"persist"}).

 
FROM php:8.2-apache
 
RUN apt-get update \
    && apt-get install -y build-essential curl zlib1g-dev g++ git libicu-dev zip libzip-dev libpng-dev libjpeg-dev libwebp-dev libfreetype6-dev \
    && docker-php-ext-install intl opcache pdo pdo_mysql \
    && pecl install apcu \
    && docker-php-ext-enable apcu \
    && docker-php-ext-configure zip \
    && docker-php-ext-install zip
 
RUN docker-php-ext-configure gd --with-freetype --with-webp --with-jpeg \
    && docker-php-ext-install  gd \
    && docker-php-ext-install exif
 
RUN a2enmod rewrite && a2enmod ssl && a2enmod socache_shmcb
 
WORKDIR /var/www
 
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
 
RUN curl -sS https://get.symfony.com/cli/installer | bash
RUN mv /root/.symfony5/bin/symfony /usr/local/bin/symfony
 
RUN git config --global user.email "bla@bla.fr"
RUN git config --global user.name "blabla"

 
services:
  database:
    container_name: database
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: jo2024
      MYSQL_USER: jo2024
      MYSQL_PASSWORD: jo2024
    ports:
      - '4306:3306'
    volumes:
      - ./mysql:/var/lib/mysql:rw
  php:
    container_name: php
    build:
      context: ./php
    ports:
      - 8080:80     
    volumes:
      - ./apache/default.conf:/etc/apache2/sites-enabled/000-default.conf  
      - ./app:/var/www
    depends_on:
      - database
  phpma:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    environment:
      PMA_ARBITRARY: 1
      PMA_HOST: database
      PMA_USER: root
      PMA_PASSWORD: secret
      UPLOAD_LIMIT: 20M
    ports:
      - 8899:80
  mailhog:
    image: mailhog/mailhog
    logging:
      driver: 'none'
    ports:
      - 1025:1025 #SMTP
      - 8025:8025 #Boite mail

<VirtualHost *:80>
    DocumentRoot /var/www/public
 
    <Directory /var/www/public>
        AllowOverride None
        Order Allow,Deny
        Allow from All
 
        <IfModule mod_rewrite.c>
            RewriteEngine On
            RewriteCond %{REQUEST_FILENAME} !-f
            RewriteRule ^(.*)$ index.php [QSA,L]
        </IfModule>
    </Directory>
</VirtualHost>

 
        {% block javascripts %}
            {% block importmap %}{{ importmap('app') }}{% endblock %}
            <script src="{{asset('JS/testA.js')}}"></script>
            <script src="../public/testB.js"></script>
        {% endblock %}

 
<div id="signalement">
     <p>ceci est un test</p>
</div>