ap2i/src/Service/Organization/OrganizationFactory.php

<?php

namespace App\Service\Organization;

use App\ApiResources\Organization\OrganizationCreationRequest;
use App\ApiResources\Organization\OrganizationDeletionRequest;
use App\ApiResources\Organization\OrganizationMemberCreationRequest;
use App\Entity\Access\Access;
use App\Entity\Billing\BillingSetting;
use App\Entity\Core\AddressPostal;
use App\Entity\Core\ContactPoint;
use App\Entity\Education\CriteriaNotation;
use App\Entity\Education\Cycle;
use App\Entity\Network\NetworkOrganization;
use App\Entity\Organization\Organization;
use App\Entity\Organization\OrganizationAddressPostal;
use App\Entity\Organization\Parameters;
use App\Entity\Organization\Settings;
use App\Entity\Organization\Subdomain;
use App\Entity\Person\Person;
use App\Entity\Person\PersonAddressPostal;
use App\Enum\Core\ContactPointTypeEnum;
use App\Enum\Education\CycleEnum;
use App\Enum\Network\NetworkEnum;
use App\Enum\Organization\AddressPostalOrganizationTypeEnum;
use App\Enum\Person\AddressPostalPersonTypeEnum;
use App\Repository\Core\CountryRepository;
use App\Repository\Organization\OrganizationRepository;
use App\Repository\Person\PersonRepository;
use App\Service\Dolibarr\DolibarrApiService;
use App\Service\Typo3\BindFileService;
use App\Service\Typo3\SubdomainService;
use App\Service\Typo3\Typo3Service;
use App\Service\Utils\DatesUtils;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use Elastica\Param;
use Exception;
use libphonenumber\NumberParseException;
use libphonenumber\PhoneNumberUtil;
use Psr\Log\LoggerInterface;
use SebastianBergmann\Type\RuntimeException;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\String\ByteString;
use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
use Symfony\Contracts\Service\Attribute\Required;
use Throwable;
use App\Service\Organization\Utils as OrganizationUtils;

class OrganizationFactory
{
    private LoggerInterface $logger;

    public function __construct(
        private readonly SubdomainService       $subdomainService,
        private readonly OrganizationRepository $organizationRepository,
        private readonly CountryRepository      $countryRepository,
        private readonly OrganizationUtils      $organizationUtils,
        private readonly Typo3Service           $typo3Service,
        private readonly DolibarrApiService     $dolibarrApiService,
        private readonly EntityManagerInterface $entityManager,
        private readonly PersonRepository       $personRepository,
        private readonly BindFileService        $bindFileService,
    ) {}

    #[Required]
    /** @see https://symfony.com/doc/current/logging/channels_handlers.html#how-to-autowire-logger-channels */
    public function setLoggerInterface(LoggerInterface $adminLogger): void
    {
        $this->logger = $adminLogger;
    }

    /**
     * Créé une nouvelle organisation à partir des données contenues dans une OrganizationCreationRequest
     *
     * @param OrganizationCreationRequest $organizationCreationRequest
     * @return Organization
     * @throws TransportExceptionInterface
     * @throws Throwable
     */
    public function create(OrganizationCreationRequest $organizationCreationRequest): Organization
    {
        $this->logger->info(
            "Start the creation of a new organization named '" . $organizationCreationRequest->getName() . "'"
        );

        $this->entityManager->beginTransaction();

        try {
            // On vérifie si cette organisation n'existe pas déjà
            if ($this->isExistingOrganization($organizationCreationRequest)) {
                throw new \RuntimeException('An organization named ' . $organizationCreationRequest->getName() . ' already exists');
            }

            // On vérifie la validité et la disponibilité du sous domaine
            $this->validateSubdomain($organizationCreationRequest->getSubdomain());
            $this->logger->info("Subdomain is valid and available : '" . $organizationCreationRequest->getSubdomain() . "'");

            // On construit l'organisation et ses relations
            $organization = $this->makeOrganizationWithRelations($organizationCreationRequest);
            $this->logger->info("Organization created with all its relations");

            // On persiste et on commit
            $this->entityManager->persist($organization);
            $this->entityManager->flush();

            // Création de la société Dolibarr
            $dolibarrId = $this->dolibarrApiService->createSociety(
                $organization,
                $organizationCreationRequest->isClient()
            );
            $this->logger->info("New dolibarr structure created (uid : " . $dolibarrId . ")");

            $this->entityManager->commit();
            $this->logger->debug(" - New entities committed in DB");

            $this->logger->info("Organization persisted in the DB");

        } catch (\Exception $e) {
            $this->logger->critical("An error happened, operation cancelled\n" . $e);
            $this->entityManager->rollback();
            throw $e;
        }

        // Register the subdomain into the BindFile (takes up to 5min to take effect)
        $this->bindFileService->registerSubdomain($organizationCreationRequest->getSubdomain());
        $this->logger->info("Subdomain registered");

        // Création du site typo3 (on est obligé d'attendre que l'organisation soit persistée en base)
        if ($organizationCreationRequest->getCreateWebsite()) {
            $this->createTypo3Website($organization);
        } else {
            $this->logger->warning("Typo3 website creation was not required");
        }

        return $organization;
    }

    /**
     * Une organisation du même nom existe-t-elle déjà à la même adresse ?
     *
     * @param OrganizationCreationRequest $organizationCreationRequest
     * @return bool
     */
    protected function isExistingOrganization(OrganizationCreationRequest $organizationCreationRequest): bool
    {
        return $this
            ->organizationRepository
            ->count(
                [
                    'name' => $organizationCreationRequest->getName(),
                ]
            ) > 0;
    }

    /**
     * Vérifie la disponibilité et la validité d'un sous domaine
     *
     * @param string $subdomainValue
     * @return void
     * @throws \Exception
     */
    protected function validateSubdomain(string $subdomainValue): void
    {
        if (!$this->subdomainService->isValidSubdomain($subdomainValue)) {
            throw new \RuntimeException("Not a valid subdomain : " . $subdomainValue);
        }

        if ($this->subdomainService->isReservedSubdomain($subdomainValue)) {
            throw new \RuntimeException("This subdomain is not available : " . $subdomainValue);
        }

        if ($this->subdomainService->isRegistered($subdomainValue)) {
            throw new \RuntimeException("This subdomain is already registered : " . $subdomainValue);
        }
    }

    /**
     * Créé une nouvelle instance d'organisation, et toutes les instances liées (paramètres, contact, adresses, ...),
     * selon le contenu de la requête de création.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest
     * @return Organization
     * @throws Throwable
     */
    protected function makeOrganizationWithRelations(
        OrganizationCreationRequest $organizationCreationRequest
    ): Organization
    {
        // Création de l'organisation
        $organization = $this->makeOrganization($organizationCreationRequest);
        $this->logger->debug(" - Organization created");

        // Création des Parameters
        $parameters = $this->makeParameters($organizationCreationRequest);
        $organization->setParameters($parameters);
        $this->logger->debug(" - Parameters created");

        // Création des Settings
        $settings = $this->makeSettings($organizationCreationRequest);
        $organization->setSettings($settings);
        $this->logger->debug(" - Settings created");

        // Création de l'adresse postale
        $organizationAddressPostal = $this->makePostalAddress($organizationCreationRequest);
        $organization->addOrganizationAddressPostal($organizationAddressPostal);
        $this->logger->debug(" - OrganizationAddressPostal created");

        // Création du point de contact
        $contactPoint = $this->makeContactPoint($organizationCreationRequest);
        $organization->addContactPoint($contactPoint);
        $this->logger->debug(" - ContactPoint created");

        // Rattachement au réseau
        $networkOrganization = $this->makeNetworkOrganization($organizationCreationRequest);
        $organization->addNetworkOrganization($networkOrganization);
        $this->logger->debug(" - NetworkOrganization created");

        // Créé l'admin
        $adminAccess = $this->makeAdminAccess($organizationCreationRequest);
        $organization->addAccess($adminAccess);
        $this->logger->debug(" - Admin access created");

        // Création des cycles
        foreach ($this->makeCycles() as $cycle) {
            $organization->addCycle($cycle);
        }
        $this->logger->debug(" - Cycles created");

        // Création du président (si renseigné)
        $presidentCreationRequest = $organizationCreationRequest->getPresident();
        if ($presidentCreationRequest !== null) {
            $presidentAccess = $this->makeAccess($presidentCreationRequest);
            $organization->addAccess($presidentAccess);
            $this->logger->debug(" - President access created");
        }

        // Création du directeur (si renseigné)
        $directorCreationRequest = $organizationCreationRequest->getDirector();
        if ($directorCreationRequest !== null) {
            $directorAccess = $this->makeAccess($directorCreationRequest);
            $organization->addAccess($directorAccess);
            $this->logger->debug(" - Director access created");
        }

        // Création du sous-domaine
        $subdomain = $this->makeSubdomain($organizationCreationRequest);
        $subdomain->setOrganization($organization);

        // <--- Pour la rétrocompatibilité avec la v1 ; pourra être supprimé lorsque la migration sera achevée
        $parameters = $organization->getParameters();
        $parameters->setSubDomain($organizationCreationRequest->getSubdomain());
        $parameters->setOtherWebsite('https://' . $organizationCreationRequest->getSubdomain() . '.opentalent.fr');
        $this->entityManager->persist($parameters);
        // --->
        $this->logger->debug(" - Subdomain created");

        return $organization;
    }

    /**
     * Créé une nouvelle instance d'organisation
     *
     * @param OrganizationCreationRequest $organizationCreationRequest
     * @return Organization
     */
    protected function makeOrganization(OrganizationCreationRequest $organizationCreationRequest): Organization
    {
        // Création de l'organisation
        $organization = new Organization();
        $organization->setName($organizationCreationRequest->getName());
        $organization->setLegalStatus($organizationCreationRequest->getLegalStatus());
        $organization->setPrincipalType($organizationCreationRequest->getPrincipalType());
        $organization->setIdentifier($organizationCreationRequest->getIdentifier());

        $this->entityManager->persist($organization);

        return $organization;
    }

    /**
     * Create a new Parameters object from the data in an OrganizationCreationRequest
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The organization creation request
     * @return Parameters The created Parameters object
     * @throws Throwable If there is an error
     */
    protected function makeParameters(OrganizationCreationRequest $organizationCreationRequest): Parameters
    {
        $parameters = new Parameters();
        $this->entityManager->persist($parameters);
        return $parameters;
    }

    /**
     * Creates a new instance of the Settings class based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The OrganizationCreationRequest object containing the required data.
     *
     * @return Settings The newly created instance of the Settings class.
     */
    protected function makeSettings(OrganizationCreationRequest $organizationCreationRequest): Settings
    {
        $settings = new Settings();
        $settings->setProduct($organizationCreationRequest->getProduct());
        $this->entityManager->persist($settings);
        return $settings;
    }

    /**
     * Creates a new instance of the OrganizationAddressPostal class based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The OrganizationCreationRequest object containing the required data.
     *
     * @return OrganizationAddressPostal The newly created instance of the OrganizationAddressPostal class.
     */
    protected function makePostalAddress(OrganizationCreationRequest $organizationCreationRequest): OrganizationAddressPostal
    {
        $addressPostal = new AddressPostal();
        $addressPostal->setStreetAddress($organizationCreationRequest->getStreetAddress1());
        $addressPostal->setStreetAddressSecond($organizationCreationRequest->getStreetAddress2());
        $addressPostal->setStreetAddressThird($organizationCreationRequest->getStreetAddress3());
        $addressPostal->setPostalCode($organizationCreationRequest->getPostalCode());
        $addressPostal->setAddressCity($organizationCreationRequest->getCity());
        $country = $this->countryRepository->find($organizationCreationRequest->getCountryId());
        $addressPostal->setAddressCountry($country);
        $this->entityManager->persist($addressPostal);

        $organizationAddressPostal = new OrganizationAddressPostal();
        $organizationAddressPostal->setAddressPostal($addressPostal);
        $organizationAddressPostal->setType(AddressPostalOrganizationTypeEnum::ADDRESS_HEAD_OFFICE);
        $this->entityManager->persist($organizationAddressPostal);

        return $organizationAddressPostal;
    }

    /**
     * Creates a new instance of the ContactPoint class based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The OrganizationCreationRequest object containing the required data.
     *
     * @return ContactPoint The newly created instance of the ContactPoint class.
     * @throws NumberParseException
     */
    protected function makeContactPoint(OrganizationCreationRequest $organizationCreationRequest): ContactPoint
    {
        $phoneUtil = PhoneNumberUtil::getInstance();
        $phoneNumber = $phoneUtil->parse($organizationCreationRequest->getPhoneNumber());

        $contactPoint = new ContactPoint();
        $contactPoint->setContactType(ContactPointTypeEnum::PRINCIPAL);
        $contactPoint->setEmail($organizationCreationRequest->getEmail());
        $contactPoint->setTelphone($phoneNumber);
        $this->entityManager->persist($contactPoint);

        return $contactPoint;
    }

    /**
     * Creates a new instance of the NetworkOrganization class based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The OrganizationCreationRequest object containing the required data.
     *
     * @return NetworkOrganization The newly created instance of the NetworkOrganization class.
     *
     * @throws \RuntimeException|\Exception if no parent organization is found for the given parent ID or if no network is found for the given network ID.
     */
    protected function makeNetworkOrganization(OrganizationCreationRequest $organizationCreationRequest): NetworkOrganization
    {
        $parent = $this->organizationRepository->find($organizationCreationRequest->getParentId());
        if (!$parent) {
            throw new \RuntimeException('No parent organization found for id ' . $organizationCreationRequest->getParentId());
        }

        $networkOrganization = $this->organizationUtils->getActiveNetworkOrganization($parent);
        if (!$networkOrganization) {
            throw new \RuntimeException('No network found for parent ' . $organizationCreationRequest->getParentId());
        }

        $network = $networkOrganization->getNetwork();

        // Si réseau CMF, on vérifie que le matricule est valide
        if ($network->getId() === NetworkEnum::CMF->value) {
            if (!preg_match("/FR\d{12}/", $organizationCreationRequest->getIdentifier())) {
                throw new \RuntimeException("CMF identifier is missing or invalid.");
            }
        }

        $networkOrganization = new NetworkOrganization();
        $networkOrganization->setParent($parent);
        $networkOrganization->setNetwork($network);
        $networkOrganization->setStartDate(DatesUtils::new());
        $this->entityManager->persist($networkOrganization);

        return $networkOrganization;
    }

    /**
     * Creates a new instance of the Access class with admin access based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationCreationRequest $organizationCreationRequest The OrganizationCreationRequest object containing the required data.
     *
     * @return Access The newly created instance of the Access class with admin access.
     */
    protected function makeAdminAccess(OrganizationCreationRequest $organizationCreationRequest): Access
    {
        $admin = new Person();
        $admin->setUsername('admin' . strtolower($organizationCreationRequest->getSubdomain()));
        $randomString = ByteString::fromRandom(32)->toString();
        $admin->setPassword($randomString);
        $this->entityManager->persist($admin);

        $adminAccess = new Access();
        $adminAccess->setAdminAccess(true);
        $adminAccess->setPerson($admin);
        $this->entityManager->persist($adminAccess);

        return $adminAccess;
    }

    /**
     * Creates an array of Cycle objects based on a predefined set of data.
     *
     * @return Cycle[] An array of Cycle objects.
     */
    protected function makeCycles(): array
    {
        $cyclesData = [
            ['Cycle initiation', 10, CycleEnum::INITIATION_CYCLE],
            ['Cycle 1', 20, CycleEnum::CYCLE_1],
            ['Cycle 2', 30, CycleEnum::CYCLE_2],
            ['Cycle 3', 40, CycleEnum::CYCLE_3],
            ['Cycle 4', 50, CycleEnum::CYCLE_4],
            ['Hors cycle', 60, CycleEnum::OUT_CYCLE],
        ];

        $cycles = [];

        foreach ($cyclesData as $cycleData) {
            $cycle = new Cycle();
            $cycle->setLabel($cycleData[0]);
            $cycle->setOrder($cycleData[1]);
            $cycle->setCycleEnum($cycleData[2]);
            $cycle->setIsSystem(false);
            $this->entityManager->persist($cycle);
            $cycles[] = $cycle;
        }

        return $cycles;
    }

    /**
     * Creates an Access object based on the given OrganizationMemberCreationRequest.
     *
     * @param int|OrganizationMemberCreationRequest $creationRequestData The request object containing the
     *                                                                   necessary data for creating a Person object,
     *                                                                   or the id of an existing one.
     * @return Access The created Access object.
     * @throws NumberParseException
     */
    protected function makeAccess(
        int | OrganizationMemberCreationRequest $creationRequestData
    ): Access
    {
        if (is_int($creationRequestData)) {
            $person = $this->personRepository->find($creationRequestData);
        } else {
            $person = new Person();

            $person->setUsername($creationRequestData->getUsername());
            $person->setPassword(ByteString::fromRandom(32)->toString());
            $person->setGender($creationRequestData->getGender());
            $person->setName(
                ucfirst(strtolower($creationRequestData->getName()))
            );
            $person->setGivenName(
                ucfirst(strtolower($creationRequestData->getGivenName()))
            );

            $personPostalAddress = $this->makePersonPostalAddress($creationRequestData);
            $person->addPersonAddressPostal($personPostalAddress);

            $contactPoint = $this->makePersonContactPoint($creationRequestData);
            $person->addContactPoint($contactPoint);

            $this->entityManager->persist($person);
        }

        $access = new Access();
        $access->setPerson($person);
        $this->entityManager->persist($access);

        return $access;
    }

    /**
     * Creates a PersonAddressPostal object based on the given OrganizationMemberCreationRequest.
     *
     * @param OrganizationMemberCreationRequest $organizationMemberCreationRequest The request object containing the
     *                                                                             necessary data for creating a
     *                                                                             PersonAddressPostal object.
     * @return PersonAddressPostal The created PersonAddressPostal object.
     */
    protected function makePersonPostalAddress(OrganizationMemberCreationRequest $organizationMemberCreationRequest): PersonAddressPostal
    {
        $addressPostal = new AddressPostal();
        $addressPostal->setStreetAddress($organizationMemberCreationRequest->getStreetAddress1());
        $addressPostal->setStreetAddressSecond($organizationMemberCreationRequest->getStreetAddress2());
        $addressPostal->setStreetAddressThird($organizationMemberCreationRequest->getStreetAddress3());
        $addressPostal->setPostalCode($organizationMemberCreationRequest->getPostalCode());
        $addressPostal->setAddressCity($organizationMemberCreationRequest->getCity());

        $country = $this->countryRepository->find($organizationMemberCreationRequest->getCountryId());
        $addressPostal->setAddressCountry($country);
        $this->entityManager->persist($addressPostal);

        $personAddressPostal = new PersonAddressPostal();
        $personAddressPostal->setAddressPostal($addressPostal);
        $personAddressPostal->setType(AddressPostalPersonTypeEnum::ADDRESS_PRINCIPAL);
        $this->entityManager->persist($personAddressPostal);

        return $personAddressPostal;
    }

    /**
     * Creates a new instance of the ContactPoint class based on the given OrganizationCreationRequest object.
     *
     * @param OrganizationMemberCreationRequest $organizationMemberCreationRequest The OrganizationMemberCreationRequest object containing the required data.
     *
     * @return ContactPoint The newly created instance of the ContactPoint class.
     * @throws NumberParseException
     */
    protected function makePersonContactPoint(OrganizationMemberCreationRequest $organizationMemberCreationRequest): ContactPoint
    {
        $phoneUtil = PhoneNumberUtil::getInstance();
        $phoneNumber = $phoneUtil->parse($organizationMemberCreationRequest->getPhone());

        $contactPoint = new ContactPoint();
        $contactPoint->setContactType(ContactPointTypeEnum::PRINCIPAL);
        $contactPoint->setEmail($organizationMemberCreationRequest->getEmail());
        $contactPoint->setTelphone($phoneNumber);

        if ($organizationMemberCreationRequest->getMobile() !== null) {
            $mobileNumber = $phoneUtil->parse($organizationMemberCreationRequest->getMobile());
            $contactPoint->setMobilPhone($mobileNumber);
        }

        $this->entityManager->persist($contactPoint);
        return $contactPoint;
    }

    protected function makeSubdomain(OrganizationCreationRequest $organizationCreationRequest): Subdomain
    {
        $subdomain = new Subdomain();
        $subdomain->setSubdomain($organizationCreationRequest->getSubdomain());
        $subdomain->setActive(true);
        $this->entityManager->persist($subdomain);

        return $subdomain;
    }

    /**
     * Créé le site Typo3 et retourne l'id de la page racine du site nouvellement créé, ou null en cas d'erreur
     *
     * @throws RedirectionExceptionInterface
     * @throws ClientExceptionInterface
     * @throws TransportExceptionInterface
     * @throws ServerExceptionInterface
     */
    protected function createTypo3Website(Organization $organization): ?int {
        $response = $this->typo3Service->createSite($organization->getId());
        $rootPageUid = json_decode($response->getContent(), true);

        if ($response->getStatusCode() === Response::HTTP_OK && $rootPageUid > 0) {
            // TODO: revoir l'utilité du champs cmsId
            $organization->setCmsId($rootPageUid);
            $this->entityManager->persist($organization);
            $this->entityManager->flush();

            return $rootPageUid;
        } else {
            $this->logger->critical("/!\ A critical error happened while creating the Typo3 website");
            $this->logger->debug($response->getContent());
        }

        return null;
    }

    /**
     * /!\ Danger zone /!\
     *
     * Supprime définitivement une organisation, ses données, ses fichiers, son site internet, et son profil Dolibarr.
     *
     * Pour éviter une suppression accidentelle, cette méthode ne doit pouvoir être exécutée que si la requête a été
     * envoyée depuis le localhost.
     *
     * @param OrganizationDeletionRequest $organizationDeletionRequest
     * @return OrganizationDeletionRequest
     * @throws Exception
     */
    public function delete(OrganizationDeletionRequest $organizationDeletionRequest): OrganizationDeletionRequest
    {
        $this->preventIfNotLocalhost();

        $organization = $this->organizationRepository->find($organizationDeletionRequest->getOrganizationId());

        $this->logger->info(
            "Start the deletion of organization '" . $organization->getName() . "' [" . $organization->getId() . "]"
        );

        $this->entityManager->beginTransaction();

        $withError = false;

        try {
            // On doit gérer à part la suppression des Access afin de supprimer au passage les Person devenues 'orphelines'
            $this->deleteOrganizationAccesses($organization);

            // On est obligé de supprimer manuellement les paramètres, car c'est l'entité Parameters qui est
            // propriétaire de la relation Organization ↔ Parameters.
            $this->entityManager->remove($organization->getParameters());

            // Toutes les autres entités liées seront supprimées en cascade
            $this->entityManager->remove($organization);

            $this->entityManager->flush();
            $this->entityManager->commit();
        } catch (\Exception $e) {
            $this->logger->critical("An error happened, operation cancelled\n" . $e);
            $this->entityManager->rollback();
            throw $e;
        }

        try {
            $this->deleteTypo3Website($organization);
        } catch (\Exception $e) {
            $this->logger->critical("An error happened while deleting the Typo3 website, please proceed manually.");
            $this->logger->debug($e);
            $withError = true;
        }

        try {
            $this->deleteDolibarrSociety($organization);
        } catch (\Exception $e) {
            $this->logger->critical("An error happened while deleting the Dolibarr society, please proceed manually.");
            $this->logger->debug($e);
            $withError = true;
        }

        try {
            $this->deleteLocalDirectories($organization);
        } catch (\Exception $e) {
            $this->logger->critical("An error happened while deleting the local directories, please proceed manually.");
            $this->logger->debug($e);
            $withError = true;
        }

        try {
            $this->deleteDirectoriesV1($organization);
        } catch (\Exception $e) {
            $this->logger->critical("An error happened while deleting the V1 directories, please proceed manually.");
            $this->logger->debug($e);
            $withError = true;
        }

        try {
            $this->deleteDirectories59($organization);
        } catch (\Exception $e) {
            $this->logger->critical("An error happened while deleting the 5.9 directories, please proceed manually.");
            $this->logger->debug($e);
            $withError = true;
        }

        if ($withError) {
            $organizationDeletionRequest->setStatus(OrganizationDeletionRequest::STATUS_OK_WITH_ERRORS);
            $this->logger->warning("-- Operation ended with errors, check the logs for more information --");
        } else {
            $organizationDeletionRequest->setStatus(OrganizationDeletionRequest::STATUS_OK);
        }

        return $organizationDeletionRequest;
    }

    /**
     * Lève une exception si la méthode a été appelée dans le cadre d'un appel API originaire d'un hôte
     * différent de localhost.
     *
     * @return void
     */
    protected function preventIfNotLocalhost(): void
    {
        if (
            $_SERVER &&
            $_SERVER['APP_ENV'] !== 'docker' &&
            $_SERVER['SERVER_ADDR'] !== $_SERVER['REMOTE_ADDR']
        ) {
            throw new \RuntimeException("This operation is restricted to localhost");
        }
    }

    /**
     * Supprime tous les Access d'une organisation, ainsi que la Person
     * rattachée (si celle-ci n'est pas liée à d'autres Access)
     *
     * @param Organization $organization
     * @return void
     */
    protected function deleteOrganizationAccesses(Organization $organization): void
    {
        foreach ($organization->getAccesses() as $access) {
            $person = $access->getPerson();
            if ($person->getAccesses()->count() === 1) {
                $this->entityManager->remove($person);
            }
            $this->entityManager->remove($access);
        }
    }

    // TODO: à revoir, c'est du many to many
//    protected function removeTypeOfPractices(Organization $organization): void {
//        foreach ($organization->getTypeOfPractices() as $typeOfPractice) {
//            $organization->removeTypeOfPractice($typeOfPractice);
//        }
//    }

    // TODO: à revoir, c'est du many to many
//    protected function deleteContactPoints(Organization $organization): void
//    {
//        foreach ($organization->getContactPoints() as $contactPoint) {
//            $this->entityManager->remove($contactPoint);
//        }
//    }

    // TODO: à revoir, c'est du many to many
//    protected function deleteBankAccounts(Organization $organization): void {
//        foreach ($organization->getBankAccounts() as $bankAccount) {
//            $this->entityManager->remove($bankAccount);
//        }
//    }

    protected function deleteTypo3Website(Organization $organization): void
    {
        // TODO: implement
//        $this->typo3Service->deleteSite($organization->getId());
    }

    protected function deleteDolibarrSociety(Organization $organization): void
    {
        // TODO: implement
    }

    protected function deleteLocalDirectories(Organization $organization): void
    {
        // TODO: implement
    }

    protected function deleteDirectoriesV1(Organization $organization): void
    {
        // TODO: implement
    }

    protected function deleteDirectories59(Organization $organization): void
    {
        // TODO: implement
    }
}