Admission : l'export CSV n'est possible que si la recherche ne contient que...

13.2.0

------

- Admission : l'export CSV n'est possible que si la recherche ne contient que des dossiers validés (sinon affichage d'un avertissement).

- Admission : une année universitaire d'inscription cible doit désormais être attribuée au dossier d'admission.

- [FIX] Notification de thèse déposée : warning 'Undefined variable' à cause d'une variable non fournie au template.

- [FIX] Notification 'Corrections attendues' et 'Résultats de thèses modifiés' : correction de l'erreur 'Typed property Notification\Notification::$subject must not be accessed before initialization'.

use Admission\Provider\Privilege\AdmissionPrivileges;

use Admission\Provider\Template\TexteTemplates;

use Admission\Rule\Operation\OperationRuleAwareTrait;

use Admission\Service\Admission\AdmissionRechercheServiceAwareTrait;

use Admission\Service\Admission\AdmissionRechercheService;

use Admission\Service\Admission\AdmissionServiceAwareTrait;

use Admission\Service\ConventionFormationDoctorale\ConventionFormationDoctoraleServiceAwareTrait;

use Admission\Service\Document\DocumentServiceAwareTrait;

use Admission\Service\Etat\EtatServiceAwareTrait;

use Admission\Service\Etudiant\EtudiantServiceAwareTrait;

use Admission\Service\Exporter\Admission\AdmissionExporterAwareTrait;

use Admission\Service\Exporter\Recapitulatif\RecapitulatifExporterAwareTrait;

use Admission\Service\Financement\FinancementServiceAwareTrait;

use Admission\Service\Inscription\InscriptionServiceAwareTrait;

use Application\Service\UserContextServiceAwareTrait;

use Application\Service\Variable\VariableServiceAwareTrait;

use DateTime;

use Doctorant\Entity\Db\Doctorant;

use DoctrineORMModule\Collector\SQLLoggerCollector;

use Exception;

use Fichier\Service\Fichier\FichierStorageServiceAwareTrait;

use UnicaenMultipageForm\Manager\Manager as MultipageFormManager;

use UnicaenMultipageForm\Manager\Result;

use UnicaenRenderer\Service\Rendu\RenduServiceAwareTrait;

use UnicaenSearch\SearchServiceAwareTrait;

/**

 * @property \Admission\Rule\Operation\AdmissionOperationRule $operationRule

    use AdmissionOperationServiceAwareTrait;

    use ConventionFormationDoctoraleServiceAwareTrait;

    use ApplicationRoleServiceAwareTrait;

    use AdmissionRechercheServiceAwareTrait;

    use AdmissionExporterAwareTrait;

    use TypeValidationServiceAwareTrait;

    use AdmissionValidationServiceAwareTrait;

    use RenduServiceAwareTrait;

    use VariableServiceAwareTrait;

    use EtatServiceAwareTrait;

    use SearchServiceAwareTrait;

    public SQLLoggerCollector $collector;

        $role = $this->userContextService->getSelectedRoleEcoleDoctorale();

        $ecoleDoctorale = ($role && $role->getStructure()) ? $role->getStructure()->getEcoleDoctorale() : null;

        if (($ecoleDoctoraleSourceCode && $role && $ecoleDoctorale) && $ecoleDoctoraleSourceCode !== $ecoleDoctorale->getSourceCode()){

            $this->flashMessenger()->addErrorMessage("Vous n'avez pas les droits nécessaires pour générer ces dossiers d'admission");

            return $this->redirect()->toRoute('admission');

            $this->flashMessenger()->addErrorMessage("Vous n'avez pas les droits nécessaires pour exporter ces dossiers d'admission");

            return $this->redirect()->toRoute('admission', [], ['query' => $queryParams], true);

        }

        foreach ($queryParams as $key => $value) {

            }

        }

        $this->admissionRechercheService->init();

        $this->searchService->init();

        if ($queryParams) {

            $this->admissionRechercheService->processQueryParams($queryParams);

            $this->searchService->processQueryParams($queryParams);

        }

        $seulesAdmissionValideesVisibles =

            $this->searchService->getFilterValueByName(AdmissionRechercheService::NAME_etatAdmission) === [Etat::CODE_VALIDE];

        if (!$seulesAdmissionValideesVisibles) {

            $this->flashMessenger()->addErrorMessage(

                "<p>L'opération a été annulée car seuls des dossiers validés peuvent être exportés.</p>" .

                "<p>Corrigez le filtre concerné et relancer la recherche, svp.</p>"

            );

            return $this->redirect()->toRoute('admission', [], ['query' => $queryParams], true);

        }

        $qb = $this->admissionRechercheService->getQueryBuilder();

        $qb

            ->andWhere($qb->expr()->orX('admission.etat = :etat'))

            ->setParameter('etat', Etat::CODE_VALIDE)

            ->leftJoin('admission.individu', 'i')

            ->leftJoin(Doctorant::class, 'd', 'WITH', 'd.individu = i')

            ->andWhere('d.id IS NULL');

        $listing = $qb->getQuery()->getResult();

        $admisCSV = $this->admissionExporter->exportAdmisCSV($listing);

        $admisCSV->setFilename(sprintf('sygal_admis_%s.csv', date_create()->format('Ymd_His')));

        $qb = $this->searchService->getQueryBuilder();

        return $admisCSV;

        return $this->admissionService->exporterCSV($qb);

    }

    /** TEMPLATES RENDERER *******************************************************************************/

use Admission\Service\Document\DocumentService;

use Admission\Service\Etat\EtatService;

use Admission\Service\Etudiant\EtudiantService;

use Admission\Service\Exporter\Admission\AdmissionExporter;

use Admission\Service\Exporter\Recapitulatif\RecapitulatifExporter;

use Admission\Service\Financement\FinancementService;

use Admission\Service\Inscription\InscriptionService;

use Admission\Service\Verification\VerificationService;

use Application\Service\Role\RoleService;

use Application\Service\Variable\VariableService;

use DoctrineORMModule\Collector\SQLLoggerCollector;

use Fichier\Service\Fichier\FichierStorageService;

use Individu\Service\IndividuService;

use Interop\Container\ContainerInterface;

use Laminas\ServiceManager\Factory\FactoryInterface;

use Notification\Service\NotifierService;

use Psr\Container\ContainerExceptionInterface;

use Psr\Container\NotFoundExceptionInterface;

use Psr\Container\ContainerInterface;

use Structure\Service\Etablissement\EtablissementService;

use UnicaenRenderer\Service\Rendu\RenduService;

use UnicaenSearch\SearchServicePluginManager;

class AdmissionControllerFactory implements FactoryInterface

{

    /**

     * @param ContainerInterface $container

     * @param string $requestedName

     * @param null|array $options

     * @return AdmissionController

     * @throws ContainerExceptionInterface

     * @throws NotFoundExceptionInterface

     */

    public function __invoke(ContainerInterface $container, $requestedName, array $options = null): AdmissionController

    {

        /**

        $admissionOperationService = $container->get(AdmissionOperationService::class);

        $conventionFormationDoctoraleService = $container->get(ConventionFormationDoctoraleService::class);

        $roleService = $container->get(RoleService::class);

        $admissionRechercheService = $container->get(AdmissionRechercheService::class);

        $admissionExporter = $container->get(AdmissionExporter::class);

        $admissionTypeValidationService = $container->get(TypeValidationService::class);

        $admissionValidationService = $container->get(AdmissionValidationService::class);

        $renduService = $container->get(RenduService::class);

        $controller->setAdmissionOperationService($admissionOperationService);

        $controller->setConventionFormationDoctoraleService($conventionFormationDoctoraleService);

        $controller->setApplicationRoleService($roleService);

        $controller->setAdmissionRechercheService($admissionRechercheService);

        $controller->setAdmissionExporter($admissionExporter);

        $controller->setTypeValidationService($admissionTypeValidationService);

        $controller->setAdmissionValidationService($admissionValidationService);

        $controller->setRenduService($renduService);

        $controller->setVariableService($variableService);

        $controller->setEtatService($etatService);

        /** @var AdmissionRechercheService $admissionRechercheService */

        $admissionRechercheService = $container->get(SearchServicePluginManager::class)->get(AdmissionRechercheService::class);

        $controller->setSearchService($admissionRechercheService);

        $controller->collector = $container->get('doctrine.sql_logger_collector.orm_default');

        return $controller;

    }

    /** @var AdmissionAvis | AdmissionValidation|null */

    private $operationPossible = null;

    private ?Transmission $transmission = null;

    /**

     * Constructor

     */

    {

        return $this->conventionFormationDoctorale;

    }

    public function getTransmission(): ?Transmission

    {

        return $this->transmission;

    }

    public function setTransmission(?Transmission $transmission): self

    {

        $this->transmission = $transmission;

        return $this;

    }

}

        <one-to-many field="admissionValidations" target-entity="Admission\Entity\Db\AdmissionValidation" mapped-by="admission"/>

        <one-to-many field="admissionAvis" target-entity="Admission\Entity\Db\AdmissionAvis" mapped-by="admission"/>

        <one-to-one field="transmission" target-entity="Admission\Entity\Db\Transmission" mapped-by="admission"/>

        <many-to-one field="histoModificateur" target-entity="Application\Entity\Db\Utilisateur">

            <join-columns>

                <join-column name="histo_modificateur_id" referenced-column-name="id"/>