possibilité de dépôt d'une charte doctorale signée, fix suppression validation...

ALTER TABLE admission_etudiant

DROP COLUMN numero_candidat;

-- Nouveau nature de fichier pour la charte du doctorat signée

INSERT INTO nature_fichier (id, code, libelle)

VALUES (220, 'ADMISSION_CHARTE_DOCTORAT_SIGNEE', 'Charte du doctorat signée')

ON CONFLICT DO NOTHING;

 No newline at end of file

use Application\Service\UserContextServiceAwareInterface;

use Application\Service\UserContextServiceAwareTrait;

use Doctrine\Common\Collections\Collection;

use Fichier\Entity\Db\NatureFichier;

use Individu\Service\IndividuServiceAwareTrait;

use Laminas\Permissions\Acl\Resource\ResourceInterface;

use UnicaenApp\Service\MessageCollectorAwareInterface;

                $admission->getEtat()->getCode() == (Admission::ETAT_EN_COURS_VALIDATION || Admission::ETAT_VALIDE || Admission::ETAT_REJETE),

                "Le dossier d'admission doit être en cours de validation / être validé / être rejeté"

            );

        }elseif($codeNatureFichier === NatureFichier::CODE_ADMISSION_CHARTE_DOCTORAT_SIGNEE){

            if(!($this->userContextService->getSelectedIdentityRole()->getRoleId() === Role::ROLE_ID_ADMISSION_CANDIDAT)){

                throw new FailedAssertionException("Seul le candidat peut gérer ce document");

            }

        }else{

            $this->assertTrue(

                $admission->getEtat()->getCode() == Admission::ETAT_EN_COURS_SAISIE,

use Admission\Service\Inscription\InscriptionServiceAwareTrait;

use Admission\Service\Notification\NotificationFactoryAwareTrait;

use Admission\Service\Operation\AdmissionOperationServiceAwareTrait;

use Admission\Service\TypeValidation\TypeValidationServiceAwareTrait;

use Admission\Service\Validation\AdmissionValidationServiceAwareTrait;

use Admission\Service\Verification\VerificationServiceAwareTrait;

use Application\Entity\Db\Role;

use Application\Service\Role\RoleServiceAwareTrait;

    use RoleServiceAwareTrait;

    use AdmissionRechercheServiceAwareTrait;

    use AdmissionExporterAwareTrait;

    use TypeValidationServiceAwareTrait;

    use AdmissionValidationServiceAwareTrait;

    public function indexAction(): ViewModel|Response

    {

        $response->setVariable('conventionFormationDoctoraleOperations', $conventionFormationDoctoraleOperations ?? null);

        $response->setVariable('isOperationAllowedByRole', $isOperationAllowedByRole ?? null);

        $response->setVariable('commentaires', $commentaires ?? null);

        $response->setVariable('role', $this->userContextService->getSelectedIdentityRole());

        $response->setTemplate('admission/ajouter-document');

        return $response;

    }

                    //Si on l'établissement d'inscription est modifié, on supprime l'ancienne charte doctorale, puis on ajoute la nouvelle

                    if($etablissementInscriptionBeforeUpdate !== $inscription->getEtablissementInscription()){

                        $charteDoctorat = $this->documentService->getRepository()->findByAdmissionAndNature($admission, NatureFichier::CODE_ADMISSION_CHARTE_DOCTORAT);

                        if($charteDoctorat){

                            $this->documentService->delete($charteDoctorat);

                        }

                        if($charteDoctorat) $this->documentService->delete($charteDoctorat);

                        //on supprime une possible validation déjà effectuée sur la charte du doctorat

                        $typeValidation = $this->typeValidationService->getRepository()->findOneBy(["code" => TypeValidation::CODE_ATTESTATION_HONNEUR_CHARTE_DOCTORALE]);

                        $validation = $typeValidation ? $this->admissionValidationService->getRepository()->findAdmissionValidationByTypeValidationAndAdmission($admission, $typeValidation) : null;

                        if($validation) $this->admissionValidationService->deleteAdmissionValidation($validation);

                        //On relie une charte du doctorat au dossier d'admission

                        $this->documentService->addCharteDoctoraleToAdmission($inscription);

                    }

            'showActionButtons' => false,

            'isOperationAllowedByRole' => $isOperationAllowedByRole,

            'commentaires' => $commentaires,

            'title' => "Statut du dossier d'admission de {$admission->getIndividu()}"

            'title' => "Statut du dossier d'admission de {$admission->getIndividu()}",

            'role' => $role

        ]);

    }

use Admission\Service\Inscription\InscriptionService;

use Admission\Service\Notification\NotificationFactory;

use Admission\Service\Operation\AdmissionOperationService;

use Admission\Service\TypeValidation\TypeValidationService;

use Admission\Service\Validation\AdmissionValidationService;

use Admission\Service\Verification\VerificationService;

use Application\Service\Role\RoleService;

use Fichier\Service\Fichier\FichierStorageService;

        $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);

        /** @var AdmissionOperationRule $admissionOperationRule */

        $admissionOperationRule = $container->get(AdmissionOperationRule::class);

        $controller->setRoleService($roleService);

        $controller->setAdmissionRechercheService($admissionRechercheService);

        $controller->setAdmissionExporter($admissionExporter);

        $controller->setTypeValidationService($admissionTypeValidationService);

        $controller->setAdmissionValidationService($admissionValidationService);

        return $controller;

    }

<?php

namespace Admission\Entity\Db\Repository;

use Admission\Entity\Db\Admission;

use Admission\Entity\Db\TypeValidation;

use Application\Entity\Db\Repository\DefaultEntityRepository;

use Doctrine\ORM\NonUniqueResultException;

class AdmissionValidationRepository extends DefaultEntityRepository{

    public function findAdmissionValidationByTypeValidationAndAdmission(Admission $admission, TypeValidation $typeValidation){

        $qb = $this->createQueryBuilder('aV')

            ->where('aV.admission = :admission')->setParameter('admission', $admission)

            ->andWhere('aV.typeValidation = :typeValidation')->setParameter('typeValidation', $typeValidation)

            ->andWhereNotHistorise('aV');

        try {

            return $qb->getQuery()->getOneOrNullResult();

        } catch (NonUniqueResultException $e) {

            throw new \RuntimeException("Anomalie : plus d'1 validation a été trouvée pour ce dossier d'admission/type validation", null, $e);

        }

    }

}

 No newline at end of file