src\Controller\API\ApiController.php line 138

Open in your IDE?
  1. <?php
  4. namespace App\Controller\API;
  6. use App\Entity\Admin\Branch;
  7. use App\Entity\Admin\BranchAdresse;
  8. use App\Entity\Admin\BranchProduit;
  9. use App\Entity\Admin\BranchProprietaire;
  10. use App\Entity\Admin\Department;
  11. use App\Entity\Admin\DepartmentProduit;
  12. use App\Entity\Admin\Perimetre;
  13. use App\Entity\Admin\Produit;
  14. use App\Entity\Admin\ProfilDroit;
  15. use App\Entity\Admin\Proprietaire;
  16. use App\Entity\Admin\User;
  17. use App\Entity\Admin\UserProduit;
  18. use App\Manager\Admin\PerimetreManager;
  19. use App\Manager\Admin\UserManager;
  20. use App\Manager\Admin\DashboardManager;
  21. use App\Manager\Admin\BranchAdresseManager;
  22. use App\Manager\Admin\UserProduitManager;
  23. use App\Manager\Admin\BranchManager;
  24. use App\Repository\Admin\PerimetreSystemRepository;
  25. use App\Repository\Admin\ProduitRepository;
  26. use App\Service\PasswordManager;
  27. use App\Service\ProduitApiConnector;
  28. use DateTime;
  29. use Doctrine\ORM\EntityManagerInterface;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  31. use Symfony\Component\HttpFoundation\Request;
  32. use Symfony\Component\HttpFoundation\Response;
  33. use Symfony\Component\Routing\Annotation\Route;
  34. use Symfony\Component\Security\Core\Security;
  35. use Symfony\Component\Yaml\Yaml;
  37. /**
  38.  * @Route ("/api", name="api_")
  39.  */
  40. class ApiController
  41. {
  42.     public function __construct(
  43.         private readonly EntityManagerInterface $em,
  44.         private readonly UserManager $userManager,
  45.         private readonly PerimetreManager $perimetreManager,
  46.         private readonly PerimetreSystemRepository $perimetreSystemRepository
  47.     ) {}
  49.     private function checkProduit(string $produit, ?User $user, ?Department $userDepartment, ?Branch $userBranch): string|UserProduit
  50.     {
  51.         $produitRequest = $this->em->getRepository(Produit::class)->findOneBy(["name" => $produit]);
  52.         if (empty($produitRequest)) {
  53.             return 'Produit inexistant';
  54.         }
  55.         $userProduit = $this->em->getRepository(UserProduit::class)->findOneBy(['user' => $user, 'produit' => $produitRequest, 'isActive' => true]);
  56.         if (empty($userProduit)) {
  57.             return 'Utilisateur non activé sur le produit';
  58.         }
  59.         $departmentProduit = $this->em->getRepository(DepartmentProduit::class)->findOneBy(['department' => $userDepartment, 'produit' => $produitRequest, 'isActive' => true]);
  60.         if (empty($departmentProduit)) {
  61.             return 'Service non activé sur le produit';
  62.         }
  63.         $branchProduit = $this->em->getRepository(BranchProduit::class)->findOneBy(['branch' => $userBranch, 'produit' => $produitRequest, 'isActive' => true]);
  64.         if (empty($branchProduit)) {
  65.             return 'Organisation non activée sur le produit';
  66.         }
  67.         return $userProduit;
  68.     }
  70.     private function getRequestArray(Request $request): ?array
  71.     {
  72.         return json_decode(str_replace("'", '"', $request->getContent()), true);
  73.     }
  75.     /**
  76.      * @Route ("/branch", name="branch")
  77.      */
  78.     public function getBranch(Request $request, BranchManager $branchManager, BranchAdresseManager $branchAdresseManager): ?JsonResponse
  79.     {
  80.         $requestContent = $this->getRequestArray($request);
  81.         if (!is_array($requestContent) || empty($requestContent['branch'])) return $this->returnBadAuthentication();
  82.         $branch = $branchManager->getRepository()->find($requestContent['branch']);
  83.         $proprietaires = [];
  84.         if ($branch->getBranchProprietaires()) {
  85.             foreach ($branch->getBranchProprietaires() as $bp) {
  86.                 if (empty($bp->getDeletedAt())) {
  87.                     $proprietaires[$bp->getProprietaire()->getCode()]['mnemonique'] = $bp->getMnemonique();
  88.                 }
  89.             }
  90.         }
  91.         $content = [
  92.             "branch_id" => $branch->getId(),
  93.             "branch_name" => $branch->getMnemonique(),
  94.             'branch_raison_sociale' => $branch->getRaisonSociale(),
  95.             'branch_siret' => $branch->getSiret(),
  96.             'branch_telephone' => $branch->getTelephone(),
  97.             'branch_adresses' => $branchAdresseManager->formatAll($branch->getAdresses('postal'), true) + $branchAdresseManager->formatAll($branch->getAdresses(), true),
  98.             'proprietaires' => $proprietaires
  99.         ];
  101.         return new JsonResponse(['message' => 'ok', 'branch' => $content]);
  102.     }
  104.     /**
  105.      * @Route ("/user/accept", name="user_accept_cg")
  106.      */
  107.     public function acceptedCG(Request $request, UserProduitManager $userProduitManager): ?JsonResponse
  108.     {
  109.         $requestContent = $this->getRequestArray($request);
  110.         if (!is_array($requestContent)) return $this->returnBadAuthentication();
  111.         if (array_key_exists('token', $requestContent)) {
  112.             $user = $this->userManager->getRepository()->findOneBy(["token" => $requestContent['token'], "deletedAt" => null]);
  113.             if (empty($user)) {
  114.                 return $this->returnBadAuthentication();
  115.             }
  116.             if (array_key_exists('produit', $requestContent)) {
  117.                 $userProduit = $userProduitManager->getRepository()->getUserProduitByUserAndProduit($user, $requestContent['produit']);
  118.                 if ($userProduit) {
  119.                     switch ($requestContent['type']) {
  120.                         case 'cgu':
  121.                             $userProduit->setCguAcceptedAt(new DateTime());
  122.                             break;
  123.                         case 'cgv':
  124.                             $userProduit->setCgvAcceptedAt(new DateTime());
  125.                             break;
  126.                     }
  127.                     $userProduitManager->update($userProduit);
  128.                     return new JsonResponse(['success' => 'ok']);
  129.                 }
  130.             }
  131.         }
  132.         return $this->returnBadAuthentication();
  133.     }
  135.     /**
  136.      * @Route ("/user", name="user")
  137.      */
  138.     public function getUser(Request $request, DashboardManager $dashboardManager, BranchAdresseManager $branchAdresseManager, PasswordManager $passwordManager, UserProduitManager $userProduitManager): ?JsonResponse
  139.     {
  140.         $requestContent = $this->getRequestArray($request);
  141.         if (!is_array($requestContent)) return $this->returnBadAuthentication();
  142.         $badAuth = false;
  143.         if (array_key_exists('username', $requestContent) and array_key_exists('password', $requestContent)) {
  144.             $user = $this->userManager->getRepository()->findOneBy(["username" => $requestContent['username'], "deletedAt" => null]);
  145.             if (empty($user)) {
  146.                 $badAuth = true;
  147.                 $this->userManager->addWrongUsername($requestContent['username'], $requestContent['ip'] ?? null);
  148.             } else {
  149.                 if (!$this->userManager->getEncoder()->isPasswordValid($user, $requestContent['password'])) {
  150.                     $this->userManager->addEchec($user, $requestContent['ip'] ?? null);
  151.                     $badAuth = true;
  152.                 } elseif (!$passwordManager->checkExpiration($user, $requestContent['produit'] ?? null)) {
  153.                     return $this->returnExpiredPassword($user, $requestContent['produit'] ?? null);
  154.                 }
  155.             }
  156.         } elseif (array_key_exists('token', $requestContent)) {
  157.             $user = $this->userManager->getRepository()->findOneBy(["token" => $requestContent['token'], "deletedAt" => null]);
  158.             if (empty($user)) {
  159.                 return $this->returnBadAuthentication();
  160.             }
  161.         } else {
  162.             return $this->returnBadAuthentication();
  163.         }
  164.         $userDepartment = $user ? $user->getDepartment() : null;
  165.         $userBranch = $user ? $userDepartment->getBranch() : null;
  167.         if (array_key_exists('produit', $requestContent)) {
  168.             $produitRequest = $this->checkProduit($requestContent['produit'], $user, $userDepartment, $userBranch);
  169.             if (is_string($produitRequest)) {
  170.                 $produitRequest = false;
  171.                 //$this->returnBadAuthentication($produitRequest);
  172.             }
  173.         } else $produitRequest = false;
  174.         if ($user && $this->userManager->checkIfEchec($user, $requestContent['produit'] ?? null)) {
  175.             return $this->returnEchecPassword($user, $requestContent['produit'] ?? null);
  176.         }
  177.         if ($badAuth) {
  178.             return $this->returnBadAuthentication();
  179.         }
  180.         $this->userManager->resetEchec($user);
  181.         $proprietaires = [];
  182.         $mnemoniques = [];
  183.         if ($user->getDepartment()->getBranch()->getBranchProprietaires()) {
  184.             foreach ($user->getDepartment()->getBranch()->getBranchProprietaires() as $bp) {
  185.                 if (empty($bp->getDeletedAt())) {
  186.                     $mnemoniques[$bp->getProprietaire()->getCode()] = $bp->getMnemonique();
  187.                 }
  188.             }
  189.         }
  190.         if ($user->getUserProprietaires()) {
  191.             foreach ($user->getUserProprietaires() as $proprietaire) {
  192.                 if ($proprietaire->getIsActive() && empty($proprietaire->getDeletedAt())) {
  193.                     if (!$produitRequest || !$produitRequest->getDefaultProprietaire() || $proprietaire == $produitRequest->getDefaultProprietaire()) {
  194.                         $proprietaires[$proprietaire->getProprietaire()->getCode()] = [
  195.                             'codeInterlocuteur' => $proprietaire->getCodeInterlocuteur(),
  196.                             'mnemonique' => $mnemoniques[$proprietaire->getProprietaire()->getCode()] ?? null
  197.                         ];
  198.                     }
  199.                 }
  200.             }
  201.         }
  203.         $content = [
  204.             'infos' => [
  205.                 'id' => $user->getId(),
  206.                 'token' => $user->getToken(),
  207.                 'username' => $user->getUsername(),
  208.                 'civility' => $user->getCivility(),
  209.                 'lastname' => $user->getLastname(),
  210.                 'firstname' => $user->getFirstname(),
  211.                 'email' => $user->getEmail(),
  212.                 'email2' => $user->getEmail2() && strpos($user->getEmail2(), ',') !== false
  213.                     ? explode(',', $user->getEmail2())[0]
  214.                     : $user->getEmail2(),
  215.                 'telephone' => $user->getTelephone(),
  216.                 'fonction' => $user->getFonction(),
  217.                 'code_interlocuteur' => $user->getCodeInterlocuteur(),
  218.                 "department_id" => $userDepartment->getId(),
  219.                 "department_name" => $userDepartment->getName(),
  220.                 "branch_id" => $userBranch->getId(),
  221.                 "branch_name" => $userBranch->getMnemonique(),
  222.                 'branch_raison_sociale' => $userBranch->getRaisonSociale(),
  223.                 'branch_siret' => $userBranch->getSiret(),
  224.                 'branch_telephone' => $userBranch->getTelephone(),
  225.                 'branch_adresses' => $branchAdresseManager->formatAll($userBranch->getAdresses('postal'), true) + $branchAdresseManager->formatAll($userBranch->getAdresses(), true),
  226.                 'access_users' => [],
  227.                 'access_departments' => [],
  228.                 'access_branches' => [],
  229.                 'proprietaires' => $proprietaires
  230.             ],
  231.         ];
  233.         // variables access
  234.         foreach ($user->getAccessUsers() as $accessUser) {
  235.             $content['infos']['access_users'][$accessUser->getId()] = $accessUser->getUsername();
  236.         }
  237.         foreach ($user->getAccessDepartments() as $accessDepartment) {
  238.             $content['infos']['access_departments'][$accessDepartment->getId()] = $accessDepartment->getName();
  239.         }
  240.         foreach ($user->getAccessBranches() as $accessBranch) {
  241.             $content['infos']['access_branches'][$accessBranch->getId()] = $accessBranch->getMnemonique();
  242.         }
  244.         // Recherche JAZ_PRODUIT :
  245.         $produitsData = [];
  246.         $produits = [];
  247.         $switchableProducts = [];
  248.         foreach ($user->getUserProfils() as $userProfil) {
  249.             if ($userProfil->getIsActive()) {
  250.                 $profil = $userProfil->getProfil();
  251.                 $profilDroits = $profil->getProfilDroits();
  252.                 foreach ($profilDroits as $profilDroit) {
  253.                     $droit = $profilDroit->getDroit();
  254.                     $produit = $droit->getProduit();
  255.                     if ($produit && (!$produitRequest || $produit == $produitRequest->getProduit())) {
  256.                         $produits[$produit->getName()] = $produit;
  257.                         if ($produit->getUrl() && (empty($produits[$requestContent['produit'] ?? '']) || $produit !== $produits[$requestContent['produit'] ?? ''])) {
  258.                             $switchableProducts[$produit->getName()] = [
  259.                                 'name' => $produit->getName(),
  260.                                 'logo' => $produit->getLogo() ? ($produit->getUrl() . $produit->getLogo()) : null,
  261.                                 'url' => $this->userManager->getSwitchUrl($user, $produit)[0] ?? null
  262.                             ];
  263.                         }
  264.                         $listCrude = [];
  265.                         if (isset($produitsData[$produit->getName()][$droit->getCode()])) {
  266.                             $listCrude = $produitsData[$produit->getName()][$droit->getCode()];
  267.                         }
  268.                         $produitsData[$produit->getName()][$droit->getCode()] = $this->formatProfilDroit($profilDroit, $listCrude);
  269.                     }
  270.                 }
  271.             }
  272.         }
  273.         $content['rights'] = $produitsData;
  274.         $content['switchableProducts'] = $switchableProducts;
  276.         $hasDbAuth = [];
  277.         foreach ($produits as $produit) {
  278.             if (!isset($hasDbAuth[$produit->getName()])) {
  279.                 $branchProduit = $this->em->getRepository(BranchProduit::class)->findOneBy(['branch' => $userBranch, 'produit' => $produit]);
  280.                 $userProduit = $this->em->getRepository(UserProduit::class)->findOneBy(['user' => $user, 'produit' => $produit]);
  281.                 $hasDbAuth[$produit->getName()] = [
  282.                     'branch' => ($branchProduit ? $branchProduit->getHasDbAuth() : false),
  283.                     'user' => ($userProduit ? $userProduit->getHasDbAuth() : false),
  284.                 ];
  285.             }
  286.         }
  287.         $content['hasDbAuth'] = $hasDbAuth;
  289.         /** Gestion des dashboards */
  290.         $dashboardsData = [];
  291.         foreach ($produits as $kp => $vp) {
  292.             $dashboardsTmp = [];
  293.             $dashboards = $dashboardManager->getRepository()->getDashboardsByProductsAndUser($vp, $user);
  294.             if ($dashboards) {
  295.                 foreach ($dashboards as $dashboard) {
  296.                     $dashboardsTmp[] = $dashboardManager->formatDashboardDatas($dashboard, $user);
  297.                 }
  298.             }
  299.             $dashboardsData[$kp] = $dashboardsTmp;
  300.         }
  301.         $content['dashboards'] = $dashboardsData;
  302.         /** Fin gestion des dashboards */
  304.         // Récupération des profils - Nécessaire pour simuler les Persona des forks de l'EC TDET
  305.         $userProfils =  $user->getUserProfils();
  306.         $profils = [];
  307.         foreach ($userProfils as $userProfil) {
  308.             if ($userProfil->getIsActive()) {
  309.                 $profils[$userProfil->getProfil()->getProduit()->getName()][] = $userProfil->getProfil()->getName();
  310.             }
  311.         }
  312.         $content['profils'] = $profils;
  314.         // Fonctionnalités
  315.         $detailFonctionnalites = [];
  316.         $detailFonctionnalitesD = [];
  317.         $detailFonctionnalitesU = [];
  318.         $content['fonctionnalites'] = [];
  319.         $userFonctionnalites = $user->getUserFonctionnalites();
  320.         $department_id = $userDepartment->getId();
  321.         foreach ($userFonctionnalites as $userFonctionnalite) {
  322.             $departmentFonctionnalite = $userFonctionnalite->getDepartmentFonctionnalite();
  323.             if ($departmentFonctionnalite->getDepartment()->getId() === $department_id) {
  324.                 $detailFonctionnalite = $departmentFonctionnalite->getDetailFonctionnalite();
  325.                 $fonctionnalite = $detailFonctionnalite->getFonctionnalite();
  326.                 if (!$userFonctionnalite->getIsActive() or !$departmentFonctionnalite->getIsActive()) {
  327.                     $detailFonctionnalite->setIsDisponible(false);
  328.                 }
  329.                 if ($detailFonctionnalite->getIsDisponible()) {
  330.                     $detailFonctionnalites[$fonctionnalite->getId()] = $detailFonctionnalite;
  331.                     $detailFonctionnalitesD[$fonctionnalite->getId()] = $departmentFonctionnalite;
  332.                     $detailFonctionnalitesU[$fonctionnalite->getId()] = $userFonctionnalite;
  333.                 }
  334.             }
  335.         }
  337.         foreach ($detailFonctionnalites as $detailFonctionnalite) {
  338.             $fonctionnalite = $detailFonctionnalite->getFonctionnalite();
  339.             $contentFonctionnalite = [
  340.                 "libelle" => $detailFonctionnalite->getLibelleOverride() ?? $fonctionnalite->getLibelle(),
  341.                 "show" => $detailFonctionnalite->getIsDisponible(),
  342.             ];
  343.             if ($fonctionnalite->getType() === "field") {
  344.                 $contentFonctionnalite += [
  345.                     "required" => $detailFonctionnalite->getIsObligatoire(),
  346.                     "type" => $detailFonctionnalite->getInputType(),
  347.                     "regex" => $detailFonctionnalite->getRegexPattern(),
  348.                     "pattern" => $detailFonctionnalite->getPattern(),
  349.                     "min_length" => $detailFonctionnalite->getMinLength(),
  350.                     "max_length" => $detailFonctionnalite->getMaxLength()
  351.                 ];
  352.             } elseif (!empty($fonctionnalite->getOptionsAvailableKey())) {
  353.                 $optionsAvailable = $fonctionnalite->getOptionsAvailableKey();
  354.                 $options = $detailFonctionnalite->getOptionsKey();
  356.                 if (!empty($detailFonctionnalitesD[$fonctionnalite->getId()]) && !empty($detailFonctionnalitesD[$fonctionnalite->getId()]->getOptionsKey())) {
  357.                     $optionsAvailable = $detailFonctionnalitesD[$fonctionnalite->getId()]->getOptionsKey();
  358.                     $options = $detailFonctionnalitesD[$fonctionnalite->getId()]->getOptions();
  359.                 }
  361.                 if (!empty($detailFonctionnalitesU[$fonctionnalite->getId()]) && !empty($detailFonctionnalitesU[$fonctionnalite->getId()]->getOptionsKey())) {
  362.                     $optionsAvailable = $detailFonctionnalitesU[$fonctionnalite->getId()]->getOptionsKey();
  363.                     $options = $detailFonctionnalitesU[$fonctionnalite->getId()]->getOptions();
  364.                 }
  366.                 $optionsAvailable = explode('","', substr(substr($optionsAvailable, 2), 0, -2));
  367.                 $options = explode('","', substr(substr($options, 2), 0, -2));
  369.                 $contentOptions = [];
  370.                 foreach ($optionsAvailable as $option) {
  371.                     if (in_array($option, $options)) $contentOptions[$option] = true;
  372.                     else $contentOptions[$option] = false;
  373.                 }
  374.                 $contentFonctionnalite += ['options' => $contentOptions];
  375.             }
  376.             $keyList = [];
  377.             while (!empty($fonctionnalite->getRootId())) {
  378.                 $key = $fonctionnalite->getLibelleKey();
  379.                 if ($fonctionnalite->getType() === "field") $key = 'field_' . $key;
  380.                 $keyList[] = $key;
  381.                 $fonctionnalite = $detailFonctionnalites[$fonctionnalite->getRootId()]->getFonctionnalite();
  382.             }
  383.             $key = $fonctionnalite->getLibelleKey();
  384.             if ($fonctionnalite->getType() === "field") $key = 'field_' . $key;
  385.             $keyList[] = $key;
  386.             $arrayToFill = &$content['fonctionnalites'];
  387.             while (sizeof($keyList) > 1) {
  388.                 $key = array_pop($keyList);
  389.                 if (!array_key_exists($key, $arrayToFill)) {
  390.                     $arrayToFill[$key] = [];
  391.                 }
  392.                 $arrayToFill = &$arrayToFill[$key];
  393.                 if (!array_key_exists('options', $arrayToFill)) {
  394.                     $arrayToFill['options'] = [];
  395.                 }
  396.                 $arrayToFill = &$arrayToFill['options'];
  397.             }
  398.             $key = array_pop($keyList);
  399.             if (!array_key_exists($key, $arrayToFill)) {
  400.                 $arrayToFill[$key] = [];
  401.             }
  402.             $arrayToFill[$key] += $contentFonctionnalite;
  403.         }
  404.         $content['fonctionnalites']['indice_thresh_exetr'] = -1;
  405.         if (!empty($requestContent['produit']) && $requestContent['produit'] === 'OOFTOP') {
  406.             $get_user_const = (Yaml::parseFile('../config/custom/get_user_const.yaml') ?? []);
  407.             $match_prestations = $get_user_const['match_prestations'] ?? [];
  408.             $prestations = $get_user_const['prestations'] ?? [];
  409.             foreach ($match_prestations as $fonctionnalite => $prestas) {
  410.                 if (!isset($content['fonctionnalites'][$fonctionnalite]) || !isset($content['fonctionnalites'][$fonctionnalite]['show']) || $content['fonctionnalites'][$fonctionnalite]['show'] === false) {
  411.                     foreach ($prestas as $presta) {
  412.                         unset($prestations[$presta]);
  413.                     }
  414.                 }
  415.             }
  416.             $content['prestations'] = $prestations;
  417.         }
  419.         if (empty($requestContent['produit']) || $requestContent['produit'] === 'NOSE') {
  420.             $content['perimetre'] = $this->perimetreManager->getPerimetreByProductAndType($user->getPerimetres());
  421.         } elseif (!empty($requestContent['produit']) && !empty($produits[$requestContent['produit']])) {
  422.             $content['perimetre'] = $this->perimetreSystemRepository->getPerimetreSystemByUserAndProduct($user, $produits[$requestContent['produit']]);
  423.             $userProduit = $userProduitManager->getRepository()->getUserProduitByUserAndProduit($user, $requestContent['produit']);
  424.             if ($userProduit) {
  425.                 $content['infos']['cguAcceptedAt'] = $userProduit->getCguAcceptedAt() ? $userProduit->getCguAcceptedAt()->format('Y-m-d') : null;
  426.                 $content['infos']['cgvAcceptedAt'] = $userProduit->getCgvAcceptedAt() ? $userProduit->getCgvAcceptedAt()->format('Y-m-d') : null;
  427.             }
  428.         }
  429.         // Périmètre production
  431.         return new JsonResponse(['message' => 'ok', 'user' => $content]);
  432.     }
  434.     /**
  435.      * @Route("/password_constraints", name="password_constraints")
  436.      */
  437.     public function sendPasswordContraints(PasswordManager $passwordManager): ?JsonResponse
  438.     {
  439.         $data = $passwordManager->sendConstraints();
  440.         return new JsonResponse($data);
  441.     }
  443.     /**
  444.      * @Route("/password/init", name="password_init")
  445.      */
  446.     public function checkPasswordInitialization(Request $request): ?JsonResponse
  447.     {
  448.         $requestContent = $this->getRequestArray($request);
  449.         $username = $request->get('username') ?? (array_key_exists('username', $requestContent) ? $requestContent['username'] : null);
  450.         $token = $request->get('token') ?? (array_key_exists('username', $requestContent) ? $requestContent['token'] : null);
  451.         $plainPassword1 = $request->get('password1') ?? (array_key_exists('password1', $requestContent) ? $requestContent['password1'] : null);
  452.         $plainPassword2 = $request->get('password2') ?? (array_key_exists('password2', $requestContent) ? $requestContent['password2'] : null);
  454.         // Recherche de l'utilisateur
  455.         $user = $this->userManager->getRepository()->findOneBy(['username' => $username, 'deletedAt' => null]);
  456.         if (empty($user)) return new JsonResponse(['message' => 'Bad Request', 'error' => 'Utilisateur inconnu.'], 400);
  457.         if (!empty($token)) $user = $this->userManager->checkInitTokenValidity($token);
  458.         else return new JsonResponse(['message' => 'Bad Request', 'error' => ['Votre lien est arrivé à expiration. Veuillez renouveler votre demande.']], 400);
  459.         if (is_null($plainPassword1) or is_null($plainPassword2)) {
  460.             $result = ['Paramètres manquants'];
  461.         } else $result = $this->userManager->initPasswordByUser($user, $plainPassword1, $plainPassword2);
  462.         if (is_array($result)) {
  463.             return new JsonResponse(['message' => 'Bad Request', 'error' => $result], 400);
  464.         } elseif ($result instanceof User) {
  465.             $this->userManager->updatePassword($user, $plainPassword1);
  466.             return new JsonResponse(['message' => 'OK']);
  467.         }
  468.         return new JsonResponse(['message' => 'Internal Server Error'], 500);
  469.     }
  471.     /**
  472.      * @Route("/password/token/check", name="password_token_check")
  473.      */
  474.     public function checkTokenValidity(Request $request): ?JsonResponse
  475.     {
  476.         $requestContent = $this->getRequestArray($request);
  477.         $token = $request->get('token') ?? (array_key_exists('username', $requestContent) ? $requestContent['token'] : null);
  478.         $user = null;
  479.         if (!empty($token)) {
  480.             $user = $this->userManager->checkResetTokenValidity($token);
  481.             if (!$user) {
  482.                 $user = $this->userManager->checkTokenValidity($token);
  483.             }
  484.         }
  485.         if (!$user) {
  486.             return new JsonResponse(['message' => 'Bad Request', 'error' => ['Votre lien est arrivé à expiration. Veuillez renouveler votre demande.']], 400);
  487.         }
  488.         return new JsonResponse(['message' => 'Ok']);
  489.     }
  491.     /**
  492.      * @Route("/password/reset/check", name="password_reset_check")
  493.      */
  494.     public function checkPasswordReset(Request $request): ?JsonResponse
  495.     {
  496.         $requestContent = $this->getRequestArray($request);
  497.         $username = $request->get('username') ?? (array_key_exists('username', $requestContent) ? $requestContent['username'] : null);
  498.         $token = $request->get('token') ?? (array_key_exists('username', $requestContent) ? $requestContent['token'] : null);
  499.         $plainPassword1 = $request->get('password1') ?? (array_key_exists('password1', $requestContent) ? $requestContent['password1'] : null);
  500.         $plainPassword2 = $request->get('password2') ?? (array_key_exists('password2', $requestContent) ? $requestContent['password2'] : null);
  502.         // Recherche de l'utilisateur
  503.         $user = $this->userManager->getRepository()->findOneBy(['username' => $username, 'deletedAt' => null]);
  504.         if (empty($user)) return new JsonResponse(['message' => 'Bad Request', 'error' => 'Utilisateur inconnu.'], 400);
  505.         if (!empty($token)) $user = $this->userManager->checkResetTokenValidity($token);
  506.         else return new JsonResponse(['message' => 'Bad Request', 'error' => ['Votre lien est arrivé à expiration. Veuillez renouveler votre demande.']], 400);
  507.         $result = $this->userManager->initPasswordByUser($user, $plainPassword1, $plainPassword2);
  508.         if (is_array($result)) {
  509.             return new JsonResponse(['message' => 'Bad Request', 'error' => $result], 400);
  510.         } elseif ($result instanceof User) {
  511.             $this->userManager->updatePassword($user, $plainPassword1);
  512.             $this->userManager->resetEchec($user);
  513.             return new JsonResponse(['message' => 'OK']);
  514.         }
  515.         return new JsonResponse(['message' => 'Internal Server Error'], 500);
  516.     }
  518.     /**
  519.      * @Route("/password/reset/request", name="password_reset_request")
  520.      */
  521.     public function requestForPasswordReset(Request $request, ProduitApiConnector $connector): ?JsonResponse
  522.     {
  523.         $requestContent = $this->getRequestArray($request);
  524.         $username = $request->get('username') ?? (array_key_exists('username', $requestContent) ? $requestContent['username'] : null);
  525.         $produitName = $request->get('produit_name') ?? (array_key_exists('produit_name', $requestContent) ? $requestContent['produit_name'] : null);
  526.         // Recherche de l'utilisateur et du produit
  527.         $user = $this->userManager->getRepository()->findOneBy(['username' => $username, 'deletedAt' => null]);
  528.         $produit = $this->em->getRepository(Produit::class)->findOneBy(['name' => $produitName]);
  529.         if (empty($user) || empty($produit)) {
  530.             return new JsonResponse(['message' => 'Bad Request', 'error' => ['Utilisateur ou produit inconnu.']], 400);
  531.         }
  532.         if ($produitName === 'NOSE') {
  533.             $this->userManager->resetPasswordForNose($username);
  534.         } else {
  535.             // JAZ 237 - reset password false
  536.             $token = $this->userManager->resetPasswordForProduit($username, false);
  538.             $organisation = $user->getDepartment()->getBranch();
  539.             $parameters = [
  540.                 'token' => $token,
  541.                 'username' => $user->getUsername(),
  542.                 'nom' => $user->getLastname() . ' ' . $user->getFirstname(),
  543.                 'email' => $user->getEmail(),
  544.                 'ste' => $organisation->getMnemonique(),
  545.             ];
  546.             $connector->sendRequestToProduit($produit, $parameters, 'GET', $produit->getResetPasswordUrl() ?? 'user/pass/reset');
  547.         }
  549.         return new JsonResponse(['message' => 'Ok']);
  550.     }
  552.     /**
  553.      * @Route("/password/edit", name="password_edit")
  554.      */
  555.     public function changePassword(Request $request): ?JsonResponse
  556.     {
  557.         $requestContent = $this->getRequestArray($request);
  558.         $username = $request->get('username') ?? (array_key_exists('username', $requestContent) ? $requestContent['username'] : null);
  559.         $token = $request->get('token') ?? (array_key_exists('username', $requestContent) ? $requestContent['token'] : null);
  560.         $plainPassword1 = $request->get('password1') ?? (array_key_exists('password1', $requestContent) ? $requestContent['password1'] : null);
  561.         $plainPassword2 = $request->get('password2') ?? (array_key_exists('password2', $requestContent) ? $requestContent['password2'] : null);
  562.         $oldPlainPassword = $request->get('old_password') ?? (array_key_exists('old_password', $requestContent) ? $requestContent['old_password'] : null);
  563.         // Recherche de l'utilisateur
  564.         $user = $this->userManager->getRepository()->findOneBy(['username' => $username, 'deletedAt' => null]);
  565.         if (empty($user)) return new JsonResponse(['message' => 'Bad Request', 'error' => ['Utilisateur inconnu.']], 400);
  566.         if ($token !== $user->getToken()) return new JsonResponse(['message' => 'Bad Request', 'error' => ['Votre lien est arrivé à expiration. Veuillez renouveler votre demande.']], 400);
  567.         if (is_null($oldPlainPassword) or is_null($plainPassword1) or is_null($plainPassword2)) {
  568.             $result = ['Paramètres manquants'];
  569.         } else {
  570.             $result = $this->userManager->updatePasswordByUser($user, $oldPlainPassword, $plainPassword1, $plainPassword2);
  571.         }
  572.         if (is_array($result)) {
  573.             return new JsonResponse(['message' => 'Bad Request', 'error' => $result], 400);
  574.         } elseif ($result instanceof User) {
  575.             $user = $this->userManager->updatePassword($user, $plainPassword1);
  576.             $this->userManager->resetEchec($user);
  577.             return new JsonResponse(['message' => 'OK', 'new_token' => $user->getToken()]);
  578.         }
  579.         return new JsonResponse(['message' => 'Internal Server Error'], 500);
  580.     }
  582.     /**
  583.      * @Route ("/droit", name="droit")
  584.      */
  585.     public function getDroit(Request $request): JsonResponse
  586.     {
  587.         $userToken = $request->get('userToken');
  588.         $produitName = $request->get('produit');
  589.         $droitCode = $request->get('codeDroit');
  590.         if (empty($userToken) || empty($produitName)) return new JsonResponse(['message' => 'Paramètre manquant'], 204);
  591.         $profilsDroits = $this->em->getRepository(ProfilDroit::class)->findForApi($userToken, $produitName, $droitCode);
  592.         $profilsDroitsResult = [];
  593.         if (!empty($profilsDroits)) {
  594.             foreach ($profilsDroits as $profilDroit) {
  595.                 $droit = $profilDroit->getDroit();
  596.                 $listCrude = [];
  597.                 if (isset($profilsDroitsResult[$droit->getCode()])) {
  598.                     $listCrude = $profilsDroitsResult[$droit->getCode()];
  599.                 }
  600.                 $profilsDroitsResult[$droit->getCode()] = $this->formatProfilDroit($profilDroit, $listCrude);
  601.             }
  602.         }
  603.         return new JsonResponse(['message' => 'ok', 'droit' => $profilsDroitsResult]);
  604.     }
  606.     /**
  607.      * @Route ("/perimetre", name="perimetre")
  608.      */
  609.     public function getPerimetre(Request $request): ?JsonResponse
  610.     {
  611.         $userToken = $request->get('userToken');
  612.         $produitName = $request->get('produit');
  613.         if (empty($userToken) || empty($produitName)) return new JsonResponse(['message' => 'Paramètre manquant'], 204);
  614.         $perimetres = $this->em->getRepository(Perimetre::class)->findForApi($userToken, $produitName);
  615.         $perimetreResult = $this->perimetreManager->getPerimetreByType($perimetres);
  616.         return new JsonResponse(['message' => 'ok', 'perimetre' => $perimetreResult]);
  617.     }
  619.     /**
  620.      * @Route("/entitesFacturation/{mnemoProprietaire}/{mnemoClient}", name="entite_facturation", methods={"GET"})
  621.      */
  622.     public function getEntitesFacturation(string $mnemoProprietaire, string $mnemoClient): ?JsonResponse
  623.     {
  624.         $proprietaire = $this->em->getRepository(Proprietaire::class)->findOneBy(['code' => $mnemoProprietaire]);
  625.         $client = $this->em->getRepository(Branch::class)->getBranchByMnemonique($mnemoClient, $proprietaire);
  626.         if ($client instanceof BranchAdresse) {
  627.             $client = $client->getBranch();
  628.         }
  629.         $entiteFacturationList = [];
  630.         if ($client && $client->getAdresses('factu', false)) {
  631.             /** @var BranchAdresse $adress */
  632.             foreach ($client->getAdresses('factu', false) as $adress) {
  633.                 $filteredArray = $adress->getProprietaires()->filter(
  634.                     function (Proprietaire $p) use ($proprietaire) {
  635.                         return $p->getId() === $proprietaire->getId();
  636.                     }
  637.                 );
  638.                 if (!$filteredArray->isEmpty()) {
  639.                     $entiteFacturationList[] = $adress->format(false, true);
  640.                 }
  641.             }
  642.         }
  643.         return new JsonResponse($entiteFacturationList);
  644.     }
  646.     /**
  647.      * @Route("/entite/factu", name="entite_factu", methods={"GET"})
  648.      */
  649.     public function getEntiteFactu(): JsonResponse
  650.     {
  651.         $addresses = $this->em->getRepository(BranchAdresse::class)->findBy(['type' => 'factu']);
  652.         $entiteFacturationList = [];
  653.         /** @var BranchAdresse $adress */
  654.         foreach ($addresses as $adress) {
  655.             $entiteFacturationList[] = $adress->format(false, true);
  656.         }
  658.         return new JsonResponse($entiteFacturationList);
  659.     }
  661.     /**
  662.      * @Route("/get/clients/proprietaire/{proprietaire}", name="search_client_by_proprietaire", methods={"GET"})
  663.      */
  664.     public function getClientsByProprietaire(string $proprietaire): JsonResponse
  665.     {
  666.         return new JsonResponse($this->em->getRepository(BranchProprietaire::class)->getElementByElement('bp.mnemonique', 'p.code', $proprietaire));
  667.     }
  668.     /**
  669.      * @Route("/get/clients/mnemonique/{mnemonique}", name="search_client_by_mnemonique", methods={"GET"})
  670.      */
  671.     public function getClientByMnemonique(string $mnemonique): Response
  672.     {
  673.         return new JsonResponse($this->em->getRepository(Branch::class)->getElementByElement('b.mnemonique', 'bp.mnemonique', $mnemonique));
  674.     }
  676.     /**
  677.      * @Route("/get/proprietaire/mnemonique/{mnemonique}", name="search_proprietaire_by_mnemonique", methods={"GET"})
  678.      */
  679.     public function getProprietairesByMnemonique(string $mnemonique): Response
  680.     {
  681.         return new JsonResponse($this->em->getRepository(Branch::class)->getElementByElement('p.code', 'bp.mnemonique', $mnemonique));
  682.     }
  684.     /**
  685.      * @Route("/get/proprietaires/client/{client}", name="search_proprietaire_by_client", methods={"GET"})
  686.      */
  687.     public function getProprietairesByClient(string $client): Response
  688.     {
  689.         return new JsonResponse($this->em->getRepository(Branch::class)->getElementByElement('p.code', 'b.mnemonique', $client));
  690.     }
  692.     /**
  693.      * @Route("/interlocuteur/{proprietaire}/{cliCode}/{cliCodeFactu}", name="entite_facturation_interlocuteur", methods={"GET"}, defaults={"cliCodeFactu"=null})
  694.      */
  695.     public function getInterlocuteurByClientProprietaire(string $proprietaire, string $cliCode, ?string $cliCodeFactu): Response
  696.     {
  697.         $users = $this->userManager->getRepository()->getInterlocuteurByEntiteFacturation($proprietaire, $cliCode, $cliCodeFactu);
  698.         $data = [];
  699.         /** @var User $user */
  700.         foreach ($users as $user) {
  701.             $data[] = [
  702.                 'id' => $user['id'],
  703.                 'firstName' => $user['firstname'],
  704.                 'lastName' => $user['lastname'],
  705.                 'codeInterlocuteur' => $user['codeInterlocuteur']
  706.             ];
  707.         }
  708.         return new JsonResponse($data);
  709.     }
  712.     /**
  713.      * @Route("/switch/{username}/{produit}", name="switch_user", methods={"GET"})
  714.      */
  715.     public function switchUser(string $username, string $produit, ProduitRepository $produitRepository, Security $security): JsonResponse
  716.     {
  717.         $user = $this->userManager->getRepository()->findByUsername($username);
  718.         $error = '';
  719.         $url = '';
  720.         if (is_null($user)) {
  721.             $user = $this->userManager->getRepository()->findOneBy(['email' => $username, 'deletedAt' => null]);
  722.         }
  723.         if ($user) {
  724.             $userDepartment = $user->getDepartment();
  725.             $userBranch = $userDepartment->getBranch();
  726.             $produitRequest = $this->checkProduit($produit, $user, $userDepartment, $userBranch);
  727.             if (is_string($produitRequest)) {
  728.                 $error = $this->returnBadAuthentication($produitRequest);
  729.             } else {
  730.                 [$url, $error] = $this->userManager->getSwitchUrl($user, $produitRepository->findOneBy(['name' => $produit]), $security->getUser());
  731.             }
  732.         } else {
  733.             $error = "L'utilisateur demandé n'existe pas.";
  734.         }
  735.         return new JsonResponse(['url' => $url, 'error' => $error, 'success' => $error ? '' : 'URL trouvée']);
  736.     }
  738.     private function formatProfilDroit(ProfilDroit $profilDroit, array $previousProfilDroitFormat = []): array
  739.     {
  740.         $droit = $profilDroit->getDroit();
  741.         $result = [
  742.             "label" => $droit->getName(),
  743.             "c" => $profilDroit->getHasCreate() ? 1 : 0,
  744.             "r" => $profilDroit->getHasRead() ? 1 : 0,
  745.             "u" => $profilDroit->getHasUpdate() ? 1 : 0,
  746.             "d" => $profilDroit->getHasDelete() ? 1 : 0,
  747.             "e" => $profilDroit->getHasExecute() ? 1 : 0,
  748.         ];
  749.         foreach ($previousProfilDroitFormat as $key => $value) {
  750.             if ($key !== 'label') {
  751.                 $result[$key] = ($value || $result[$key]) ? 1 : 0;
  752.             }
  753.         }
  754.         return $result;
  755.     }
  757.     private function returnBadAuthentication($message = ""): ?JsonResponse
  758.     {
  759.         return new JsonResponse(['message' => "Erreur d'authentification ({$message})"], 401);
  760.     }
  762.     private function returnExpiredPassword(User $user, ?string $produit): ?JsonResponse
  763.     {
  764.         if ($produit === 'NOSE')  $this->userManager->resetPasswordForNose($user->getUsername());
  765.         return new JsonResponse([
  766.             'message' => "Erreur d'authentification (Mot de passe expiré)",
  767.             'code' => 'EXPIRED',
  768.             'token' => $user->getToken(),
  769.             'resetToken' => $user->getResetToken()
  770.         ], 401);
  771.     }
  773.     private function returnEchecPassword(User $user, ?string $produit): ?JsonResponse
  774.     {
  775.         if ($produit === 'NOSE')  $this->userManager->resetPasswordForNose($user->getUsername());
  776.         return new JsonResponse([
  777.             'message' => "Erreur d'authentification (echec_password)",
  778.             'code' => 'ECHEC',
  779.             'token' => $user->getToken()
  780.         ], 401);
  781.     }
  782. }