src/Controller/admin/UserController.php line 318

Open in your IDE?
  1. <?php
  3. namespace App\Controller\admin;
  5. use App\Entity\Company;
  6. use App\Entity\FormationRegistration;
  7. use App\Entity\Log;
  8. use App\Entity\Role;
  9. use App\Entity\User;
  10. use App\Entity\UserActivity;
  11. use App\Events\Events;
  12. use App\Form\UserType;
  13. use App\Security\Voter\CompanyVoter;
  14. use App\Service\completion\CompletionService;
  15. use App\Service\datatable\Builder;
  16. use App\Service\profile\ProfileService;
  17. use App\Service\subscription\SubscriptionService;
  18. use Doctrine\Persistence\ManagerRegistry;
  19. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  20. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  23. use Symfony\Component\EventDispatcher\GenericEvent;
  24. use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  25. use Symfony\Component\Form\Extension\Core\Type\TextType;
  26. use Symfony\Component\HttpFoundation\JsonResponse;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  29. use Symfony\Component\Security\Guard\Token\PostAuthenticationGuardToken;
  30. use Symfony\Component\Routing\Annotation\Route;
  31. use Symfony\Component\Validator\Validator\ValidatorInterface;
  33. class UserController extends AbstractController
  34. {
  35.     private ManagerRegistry $managerRegistry;
  37.     public function __construct(ManagerRegistry $managerRegistry)
  38.     {
  39.         $this->managerRegistry = $managerRegistry;
  40.     }
  43.     /**
  44.      * @param Request $request
  45.      * @Security("is_granted('ROLE_RH')")
  46.      * @Route("/api/subscription/users", name="subscription-users", methods={"POST"})
  47.      */
  48.     public function fetchUsers(Request $request, ManagerRegistry $managerRegistry){
  50.         $companyID = $request->request->get('ID');
  51.         $company = $managerRegistry->getRepository(Company::class)->find($companyID);
  53.         /* @see CompanyVoter */
  54.         $this->denyAccessUnlessGranted(CompanyVoter::COMPANY_SHOW,$company);
  56.         if(!$company) {
  57.             return new JsonResponse("ko",400);
  58.         }
  60.         $dt_ajax_url = $this->generateUrl('dt-users', ['company' => $company->getId()]);
  61.         $content = $this->renderView('pages/admin/company/blocks/company.users.html.twig',[
  62.             "company"=>$company,
  63.             "users_count"=>$company->getUsers()->count(),
  64.             "dt_url"=>$dt_ajax_url,
  65.             'context'=> 'users'
  66.         ]);
  68.         $actions = $this->renderView('pages/admin/company/blocks/tab.actions.html.twig',[
  69.             'context'=> 'users',
  70.             "users_count"=>$company->getUsers()->count(),
  71.             'company' => $company
  72.         ]);
  74.         return new JsonResponse(["content"=>$content,"actions"=>$actions]);
  76.     }
  78.     /**
  79.      * @param Request $request
  80.      * @Security("is_granted('ROLE_RH')")
  81.      * @Route("/api/subscription/user", name="subscription-show-user", methods={"POST"})
  82.      */
  83.     public function fetchUser(Request $request, ManagerRegistry $managerRegistry,CompletionService $completionService,ProfileService $profileService){
  85.         $ID = $request->request->get('ID');
  86.         $user = $managerRegistry->getRepository(User::class)->find($ID);
  88.         /* @see CompanyVoter */
  89.         $this->denyAccessUnlessGranted(CompanyVoter::USER_EDIT,$user);
  91.         if(!$user) {
  92.             return new JsonResponse("ko",400);
  93.         }
  95.         $proCompletion = $completionService->getProfessional($user);
  96.         $privateCompletion = $completionService->getPrivate($user);
  98.         $userProActivities = $profileService->transformProActivitiesForRead($user);
  99.         $privateActivities = $profileService->transformPrivateActivitiesForRead($user);
  101.         //Stats visio
  102.         $logs = $this->managerRegistry->getRepository(Log::class)->getHistory($user, Events::VIDEO_COMPLETE);
  103.         $loginHistory = $this->managerRegistry->getRepository(Log::class)->getLoginHistory($user);
  105. //        if (!$this->isGranted('ROLE_ADMIN')){
  106. //            //VIDEOS only CAT === ERGO
  107. //            $logs = array_filter($logs, function ($log) {
  108. //                return isset($log['sources']['feedData']) &&  $log['sources']['feedData']['CAT'] === 'ERGO';
  109. //            });
  110. //        }
  113.         //FORMATION
  114.         if( $this->isGranted('ROLE_ADMIN') ){
  115.             $formations = $this->managerRegistry->getRepository(FormationRegistration::class)->getAllFormationViewed($user);
  116.         }
  117.         //si j suis gestionnaire > on retire les formations qui ne m'appartiennent pas
  118.         else{
  119.             $formations = $this->managerRegistry->getRepository(FormationRegistration::class)->getAllFormationViewed($user,true);
  120.         }
  122.         $content = $this->renderView('pages/admin/user/show.user.html.twig',[
  123.             "user"=>$user,
  124.             "proCompletion"=>$proCompletion,
  125.             "privateCompletion"=>$privateCompletion,
  126.             "proActivities" => $userProActivities,
  127.             "privateActivities" => $privateActivities,
  128.             "history_visio"=>$logs,
  129.             "loginHistory"=>$loginHistory,
  130.             "formations"=>$formations,
  131.             'context'=> 'users'
  132.         ]);
  135.         return new JsonResponse(["content"=>$content]);
  137.     }
  139.     /**
  140.      * RH OR ADMIN add users
  141.      * @param Request $request
  142.      * @Security("is_granted('ROLE_RH')")
  143.      * @Route("/admin/subscription/{slug}/add-users", name="admin-add-users")
  144.      * @ParamConverter("company", options={"mapping": {"slug": "slug"}})
  145.      */
  146.     public function addUsers(Request $request, Company $company, EventDispatcherInterface $eventDispatcher,
  147.                              ValidatorInterface $validator,SubscriptionService $subscriptionService)
  148.     {
  150.         /* @see CompanyVoter */
  151.         $this->denyAccessUnlessGranted(CompanyVoter::COMPANY_SHOW,$company);
  152.         /* @var $currentUser User*/
  153.         $currentUser = $this->getUser();
  155.         $hasErrors = false;
  156.         if($request->isMethod('POST')){
  159.             $em = $this->managerRegistry->getManager();
  160.             $data = $request->request->all();
  162.             //retire les lignes vides du formulaire
  163.             $allData = array_filter($data,function ($v,$k){
  164.                     return $v && $v !== "";
  165.             },ARRAY_FILTER_USE_BOTH);
  168.             //Group data by user
  169.             $usersToSave=[];
  170.             foreach ($allData as $k => $v){
  171.                 list($entity,$field,$index) = explode("_",$k);
  172.                 if(!isset( $usersToSave[$index]) && empty($usersToSave[$index])){
  173.                     $usersToSave[$index] = [];
  174.                 }
  175.                 $usersToSave[$index][$field] = $v;
  176.             }
  178.             $entityUserSaved=[];
  179.             foreach ($usersToSave as &$user){
  180.                 $_user = new User();
  182.                 if (in_array($user['role'], User::getAssignableRoleNames(), true)) {
  183.                     $user_role =$em->getRepository(Role::class)->findOneBy(['name' => $user['role']]);
  184.                 }
  185.                 else{
  186.                     $user_role =$em->getRepository(Role::class)->findOneBy(['name' => User::ROLE_USER_ACTIF]);
  187.                 }
  189.                 $_user->setRoles($user_role);
  190.                 $_user->setEmail(trim($user['email']));
  191.                 $_user->setLastname(trim($user['lastname']));
  192.                 $_user->setFirstname(trim($user['firstname']));
  194.                 if(isset($user['contact']) && $user['contact'] === "on"){
  195.                     $_user->setIsContact(1);
  196.                 }
  197.                 else{
  198.                     $_user->setIsContact(0);
  199.                 }
  201.                 $_user->setCompany($company);
  203.                 $_errors = $validator->validate($_user);
  205.                 if($_errors->count() > 0){
  206.                     $hasErrors = true;
  207.                     $user['errors'] = $_errors;
  208.                 }
  210.                 if($_errors->count() === 0){
  211.                     $em->persist($_user);
  213.                     //save user entities for emails
  214.                     array_push($entityUserSaved,$_user);
  215.                 }
  216.             }
  218.             if($subscriptionService->checkUserLimitReached($company,sizeof($usersToSave))){
  219.                 $hasErrors = true;
  220.                 $this->addFlash('notice-warning','Vous avez utilisé toutes vos licences ! Contactez votre administrateur pour en ajouter.');
  221.             }
  223.             if (!$hasErrors){
  224.                 $em->flush();
  225.                 if(sizeof($usersToSave) > 1){
  226.                     $this->addFlash('notice-success',sprintf('%d utilisateurs ont été ajoutés',sizeof($usersToSave)));
  227.                 }
  228.                 else if(sizeof($usersToSave) === 1){
  229.                     $this->addFlash('notice-success',sprintf('%d utilisateur a été ajouté',1));
  230.                 }
  232.                 //send email
  233.                 foreach ($entityUserSaved as $userSaved){
  234.                     /*Notify user by email*/
  235.                     $event = new GenericEvent($userSaved);
  236.                     $eventDispatcher->dispatch($event, Events::EMAIL_NEW_ACCOUNT);
  237.                 }
  239.                 return $this->redirectToRoute('admin-subscription-company',['slug'=>$company->getSlug(),'tab'=>'users']);
  240.             }
  242.         }
  244.         return $this->render('pages/admin/user/add.users.html.twig', [
  245.             'title_page' => $currentUser->hasRole('ROLE_RH')  ? 'Mon établissement' : 'Abonnements',
  246.             'company'=> $company,
  247.             'user_data' => ( isset($usersToSave) && $hasErrors )? $usersToSave : null
  248.         ]);
  249.     }
  251.     /**
  252.      * @param Request $request
  253.      * @Security("is_granted('ROLE_RH') or is_granted('ROLE_ADMIN')")
  254.      * @Route("/admin/user/{user}", name="admin-update-user")
  255.      */
  256.     public function updateUser(Request $request, User $user, TokenStorageInterface $tokenStorage)
  257.     {
  258.         /* @see CompanyVoter */
  259.         $this->denyAccessUnlessGranted(CompanyVoter::USER_EDIT,$user);
  261.         /** @var User $connectedUser */
  262.         $connectedUser = $this->getUser();
  263.         $editingSelf = $connectedUser->getId() === $user->getId();
  264.         $previousRole = $user->getRoles()[0] ?? null;
  266.         // Les choix dépendent du compte connecté ; la valeur initiale appartient au compte modifié.
  267.         $personal_form = $this->createForm(UserType::class, $user, [
  268.             'current_role' => $previousRole,
  269.             'actor_role' => $connectedUser->getRoles()[0] ?? null,
  270.         ]);
  271.         // $personal_form->remove('birth')->remove('gender');
  272.         if (!$this->isGranted('ROLE_RH')) {
  273.             $personal_form->remove('role');
  274.         }
  275.         $personal_form->handleRequest($request);
  277.         if ($personal_form->isSubmitted() && $personal_form->isValid()) {
  279.             $em = $this->managerRegistry->getManager();
  280.             $em->persist($user);
  281.             $em->flush();
  283.             // Renouveler uniquement la session du compte connecté après la sauvegarde.
  284.             if ($editingSelf && $previousRole !== $user->getRole()->getName()) {
  285.                 $connectedUser->setRoles($user->getRole());
  286.                 $tokenStorage->setToken(new PostAuthenticationGuardToken($connectedUser, 'main', $connectedUser->getRoles()));
  287.             }
  290.             $this->addFlash('notice-success', 'L\' utilisateur a bien été modifié');
  292.             if ($editingSelf && $user->isStandardUser()) {
  293.                 return $this->redirectToRoute('user_dashboard');
  294.             }
  296.             return $this->redirectToRoute('admin-subscription-company',['slug'=>$user->getCompany()->getSlug(),"tab"=>"users"]);
  297.         }
  299.         return $this->render('pages/admin/user/user.html.twig', [
  300.             'title_page' => 'Utilisateurs',
  301.             'personal_form' => $personal_form->createView(),
  302.             'current_user' => $user,
  303.             'context' => "update",
  304.             'company' => $user->getCompany()
  305.         ]);
  306.     }
  309.     /*AJAX*/
  311.     /**
  312.      * Alimente la datatable
  313.      * @param Request $request
  314.      * @Security("is_granted('ROLE_RH') or is_granted('ROLE_ADMIN')")
  315.      * @Route("/api/dt/company/users/{company}", name="dt-users", methods={"GET"})
  316.      * @return JsonResponse
  317.      */
  318.     public function dtCompanyUsers(Request $request, Company $company, Builder $dtBuilder, CompletionService $completionService)
  319.     {
  321.         $em = $this->managerRegistry->getManager();
  323.         $params = $request->query->all();
  324.         $roles = User::getStandardAndManagerRoleNames();
  325.         if ($this->isGranted(User::ROLE_ADMIN)) {
  326.             $roles[] = User::ROLE_ADMIN;
  327.         }
  328.         $query = $em->getRepository(User::class)->getQueryUsers($roles, $company->getId());
  331.         $columns=[
  332.             'id' => 'u.id',
  333.             'contact'=>'u.isContact',
  334.             'lastname' => 'u.lastname',
  335.             'firstname' => 'u.firstname',
  336.             'email' => 'u.email',
  337.             'role' => 'r.name',
  338.             'lastLoginAt' => 'u.lastLoginAt',
  339.             'updatedAt' => 'u.updatedAt',
  340.             ];
  342.         $dataTables = $dtBuilder
  343.             ->withColumnAliases($columns)
  344.             ->withIndexColumn('u.id')
  345.             ->withQueryBuilder($query)
  346.             ->withRequestParams($params);
  348.         $data = $dataTables->getResponse();
  350.         foreach ($data['data'] as &$d){
  351.             $user = $this->managerRegistry->getRepository(User::class)->find($d["id"]);
  352.             $d['profile'] = $completionService->getTotalUserCompletionRate($user);
  353.         }
  355.         return new JsonResponse($data);
  356.     }
  358.     /**
  359.      * check user limit process
  360.      * @param Request $request
  361.      * @Security("is_granted('ROLE_RH') or is_granted('ROLE_ADMIN')")
  362.      * @Route("/api/subscription/check-user-limit", name="check-user-limit", methods={"POST"})
  363.      * @return JsonResponse
  364.      */
  365.     public function checkUserLimit(Request $request,SubscriptionService $subscriptionService){
  367.         $ID = $request->request->get('ID');
  368.         $comp = $this->managerRegistry->getRepository(Company::class)->find($ID);
  370.         $userLimitReached = $subscriptionService->checkUserLimitReached($comp,1);
  372.         if($userLimitReached){
  373.             return new JsonResponse(0,200);
  374.         }
  376.         return new JsonResponse(1,200);
  378.     }
  380.     /**
  381.      * send invitation for given users
  382.      * @param Request $request
  383.      * @Security("is_granted('ROLE_RH') or is_granted('ROLE_ADMIN')")
  384.      * @Route("/api/user/send-invitation", name="send-invitation", methods={"POST"})
  385.      * @return JsonResponse
  386.      */
  387.     public function sendInvitation(Request $request,EventDispatcherInterface $eventDispatcher,CompletionService $completionService){
  389.         $ids = $request->request->has('ids')  ? $request->request->get('ids') : null;
  390.         $companyId = $request->request->has('company')  ? $request->request->get('company') : null;
  391.         $context = $request->request->has('context')  ? $request->request->get('context') : null;
  392.         $mode = $request->request->has('mode')  ? $request->request->get('mode') : 'exec';
  393.         $em = $this->managerRegistry->getManager();
  395.         //selection utilisateurs dans datatable
  396.         if ($ids and !empty($ids)) {
  398.             $users = $em->getRepository(User::class)->findBy(['id' => $ids]);
  400.             foreach ($users as $user) {
  402.                 /*Notify user by email*/
  403.                 $event = new GenericEvent($user);
  404.                 $eventDispatcher->dispatch($event, Events::NEW_ACCOUNT_RELANCE);
  406.             }
  408.         }
  409.         //Action globale de recherche des utilisateurs
  410.         else if($ids === null && $companyId){
  412.             try{
  414.                 $company = $em->getRepository(Company::class)->find($companyId);
  415.                 if(!$company)  return new JsonResponse('Company error',500);
  417.                 if($context === 'connection'){
  419.                     $users = $em->getRepository(User::class)->findBy(['password'=>null,'company'=>$company]);
  421.                     if($mode === 'dry'){
  422.                         return new JsonResponse([
  423.                             'users'=>sizeof($users)
  424.                         ]);
  425.                     }
  426.                     else{
  427.                         foreach ($users as $user) {
  428.                             /*Notify user by email*/
  429.                             $event = new GenericEvent($user);
  430.                             $eventDispatcher->dispatch($event, Events::NEW_ACCOUNT_RELANCE);
  432.                         }
  433.                     }
  436.                 }
  437.                 else if($context === 'completion'){
  439.                     $users =  $em->getRepository(User::class)->findUsersRegistered($company);
  440.                     $count = $completionService->findUsersCompletionLessThan($users,$mode);
  442.                     return new JsonResponse([
  443.                         'users'=>$count
  444.                     ]);
  446.                 }
  447.                 else{
  448.                     return new JsonResponse('Context error',500);
  449.                 }
  450.             }
  451.             catch (\Exception $e){
  452.                 return new JsonResponse($e->getMessage(),500);
  453.             }
  456.         }
  458.         return new JsonResponse('ok');
  459.     }
  461.     /**
  462.      * @param Request $request
  463.      * @Security("is_granted('ROLE_RH')")
  464.      * @Route("/api/user/delete", name="delete-user", methods={"DELETE"})
  465.      */
  466.     public function deleteUser(Request $request)
  467.     {
  469.         $selfUser = $this->getUser();
  471.         $em =$this->managerRegistry->getManager();
  472.         $data = $request->query->get('ids');
  473.         $outDatas = [];
  475.         if (!empty($data)) {
  477.             $users = $em->getRepository(User::class)->findBy(['id' => $data]);
  479.             foreach ($users as $user) {
  481.                 $this->denyAccessUnlessGranted(CompanyVoter::USER_DELETE,$user);
  483.                 //pas de suppression role admin
  484.                 if($user->hasRole('ROLE_ADMIN')){
  485.                     continue;
  486.                 }
  487.                 //pas de suppression RH par un RH
  488.                 if($selfUser->hasRole('ROLE_RH') && $user->hasRole('ROLE_RH')){
  489.                     return new JsonResponse('Vous ne pouvez pas supprimer un gestionnaire ! Contactez un administrateur.',403);
  490.                 }
  492.                 $em->remove($user);
  493.                 array_push($outDatas, $user->getId());
  494.             }
  496.             $em->flush();
  497.         }
  499.         return new JsonResponse($outDatas);
  500.     }
  501. }