src/Security/TemplateVoter.php line 68

Open in your IDE?
  1. <?php
  2. //------------------------------------------------------------------------------
  3. // src/Security/TemplateVoter.php
  4. //------------------------------------------------------------------------------
  5. namespace App\Security;
  7. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  8. use Symfony\Component\Security\Core\Authorization\Voter\Voter;
  9. use Doctrine\Persistence\ManagerRegistry;
  11. use App\Entity\Access;
  12. use App\Entity\Config\Config;
  13. use App\Entity\Config\Module;
  14. use App\Entity\HR\AccessFunction;
  15. use App\Entity\Ikea\TemplateProduct as IkeaTemplateProduct;
  16. use App\Entity\Product\Template;
  17. use App\Entity\Platform\Devis\Devis;
  18. use App\Entity\Platform\Devis\DevisProduct;
  19. use App\Entity\Platform\Invoice\InvoiceProduct;
  20. use App\Entity\Security\Acl;
  21. use App\Entity\Security\AclPermission;
  22. use App\Services\Config\ModuleTools;
  24. class TemplateVoter extends Voter
  25. {
  26.     //--------------------------------------------------------------------------------
  27.     // is_granted constants
  28.     const IS_ACTIVE = "template_is_active";
  30.     const ADD = "add_template";
  32.     const LISTING = "list_templates";
  33.     const VIEW = "view_template";
  34.     const EDIT = "edit_template";
  35.     const DELETE = "delete_template";
  36.     const DELETE_WITH_PRODUCTS = "delete_template_and_products";
  38.     // Plan.io Task #4561
  39.     const CHANGE_LINEAR_METERS_USAGE = "change_linear_meters_usage";
  41.     const IS_GRANTED_CONSTANTS = array(
  42.         self::IS_ACTIVE,
  43.         self::ADD,
  44.         self::LISTING,
  45.         self::VIEW,
  46.         self::EDIT,
  47.         self::DELETE,
  48.         self::DELETE_WITH_PRODUCTS,
  49.         self::CHANGE_LINEAR_METERS_USAGE,
  50.     );
  52.     //--------------------------------------------------------------------------------
  53.     // acl constants
  55.     const ACL_PERM_ADD = "template_add";
  56.     const ACL_PERM_LISTING = "template_list";
  57.     const ACL_PERM_VIEW = "template_view";
  58.     const ACL_PERM_EDIT = "template_edit";
  59.     const ACL_PERM_DELETE = "template_delete";
  61.     //--------------------------------------------------------------------------------
  63.     public function __construct(ManagerRegistry $doctrine, ModuleTools $moduleTools)
  64.     {
  65.         $this->em = $doctrine->getManager();
  66.         $this->moduleTools = $moduleTools;
  68.         $this->aclRepository = $this->em->getRepository(Acl::class);
  69.         $this->aclPermissionRepository = $this->em->getRepository(AclPermission::class);
  70.     }
  72.     // Plan.io Task #4453 [See AccessVoter for details]
  73.     public function supportsAttribute(string $attribute): bool
  74.     {
  75.         return in_array($attribute, self::IS_GRANTED_CONSTANTS, true);
  76.     }
  77.     
  78.     protected function supports(string $attribute, $subject): bool
  79.     {
  80.         // if the attribute isn't one we support, return false
  81.         if (!in_array($attribute, self::IS_GRANTED_CONSTANTS))
  82.         {
  83.             return false;
  84.         }
  86.         // only vote on Template objects inside this voter
  87.         if ($subject !== null && !$subject instanceof Template)
  88.         {
  89.             return false;
  90.         }
  92.         return true;
  93.     }
  95.     protected function voteOnAttribute(string $attribute, $subject, TokenInterface $token): bool
  96.     {
  97.         $user = $token->getUser();
  99.         if (!$user instanceof Access)
  100.         {
  101.             // the user must be logged in; if not, deny access
  102.             return false;
  103.         }
  105.         // The user must have a function; if not deny access
  106.         $function = $user->getFunction();
  107.         if ($function === null)        return false;
  109.         // Plan.io Task #3710 : Get current group
  110.         $currentGroup = $user->getSocietyGroup();
  111.         if ($currentGroup === null)
  112.             return false;
  114.         // Module activated ?
  115.         // The module is Product, it includes the Templates
  116.         if ($this->moduleTools->isInactiveByCode($currentGroup, Module::MODULE_PRODUCT))
  117.         {
  118.             return false;
  119.         }
  121.         // you know $subject is a Template object, thanks to supports
  122.         /** @var Template $template */
  123.         $template = $subject;
  125.         // Check current group affectation
  126.         if ($subject !== null)
  127.         {
  128.             $subjectGroup = $subject->getSocietyGroup();
  129.             if ($subjectGroup === null)
  130.                 return false;
  131.             if (!$currentGroup->equals($subjectGroup))
  132.                 return false;
  133.         }
  135.         switch ($attribute)
  136.         {
  137.             case self::IS_ACTIVE:
  138.                 return true;
  140.             case self::ADD:
  141.                 return $this->canAdd($user, $function);
  143.             case self::LISTING:
  144.                 return $this->canList($user, $function);
  146.             case self::VIEW:
  147.                 return $this->canView($template, $user, $function);
  148.             case self::EDIT:
  149.                 return $this->canEdit($template, $user, $function);
  150.             case self::DELETE:
  151.                 return $this->canDelete($template, $user, $function);
  152.             case self::DELETE_WITH_PRODUCTS:
  153.                 return $this->canDeleteWithProducts($template, $user, $function);
  155.             case self::CHANGE_LINEAR_METERS_USAGE:
  156.                 return $this->canChangeLinearMetersUsage($template, $user, $function);
  157.         }
  159.         throw new \LogicException('This code should not be reached!');
  160.     }
  162.     private function canChangeLinearMetersUsage(Template $template, Access $access, AccessFunction $function)
  163.     {
  164.         // If the template has an associated Method Ikea Template => Deny
  165.         $ikeaTemplates = $this->em->getRepository(IkeaTemplateProduct::class)
  166.             ->getIkeaTemplatesForPlatformTemplate($template);
  167.         if (!empty($ikeaTemplates))
  168.         {
  169.             foreach ($ikeaTemplates as $ikeaTemplate) 
  170.             {
  171.                 if ($ikeaTemplate->isMethod())
  172.                 {
  173.                     return false;
  174.                 }
  175.             }
  176.         }
  178.         // At least one Devis exists ?
  179.         $devis = $this->em->getRepository(Devis::class)->findOneByTemplate($template);
  180.         if ($devis !== null)
  181.         {
  182.             return false;
  183.         }
  185.         // All looks good => Load normal permissions
  186.         return $this->canEdit($template, $access, $function);
  187.     }
  189.     private function canAdd(Access $access, AccessFunction $function)
  190.     {
  191.         // Get Acl_Permission
  192.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_ADD);
  193.         if ($aclPerm === null)        return false;
  195.         // Get Acl
  196.         $acl = $this->aclRepository->findOneBy(array(
  197.             'function'        =>    $function,
  198.             'permission'    =>    $aclPerm
  199.         ));
  200.         if ($acl === null)        return false;
  202.         return $acl->getValue();
  203.     }
  205.     private function canList(Access $access, AccessFunction $function)
  206.     {
  207.         // Restrictions are also applied in the Controller
  208.         // But this helps speeding page loading if the access is not even allowed to load the page
  209.         // (ie. if it has no list privileges whatsoever)
  211.         // Get Acl_Permission
  212.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_LISTING);
  213.         if ($aclPerm === null)        return false;
  215.         // Get Acl
  216.         $acl = $this->aclRepository->findOneBy(array(
  217.             'function'        =>    $function,
  218.             'permission'    =>    $aclPerm
  219.         ));
  220.         if ($acl === null)        return false;
  222.         // Since only one list type can exist for the Templates,
  223.         // we can return the result of the acl_permission
  224.         return $acl->getValue();
  225.     }
  227.     private function canView(Template $template, Access $access, AccessFunction $function)
  228.     {
  229.         // Several Acl_Permission exist
  230.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_VIEW);
  232.         // If all are null, exit
  233.         if ($aclPerm === null)
  234.             return false;
  236.         // Get First one (view all)
  237.         if ($aclPerm !== null)
  238.         {
  239.             $acl = $this->aclRepository->findOneBy(array(
  240.                 'function'        =>    $function,
  241.                 'permission'    =>    $aclPerm
  242.             ));
  243.             if ($acl !== null)
  244.             {
  245.                 if ($acl->getValue())
  246.                 {
  247.                     // A single positive answer is enough
  248.                     return true;
  249.                 }
  250.             }
  251.         }
  253.         // If we are here, all hope is lost
  254.         return false;
  255.     }
  257.     private function canEdit(Template $template, Access $access, AccessFunction $function)
  258.     {
  259.         if (!$template->getIsActive())
  260.         {
  261.             return false;
  262.         }
  264.         // Several Acl_Permission exist
  265.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_EDIT);
  267.         // If all are null, exit
  268.         if ($aclPerm === null)
  269.             return false;
  271.         // Get First one (view all)
  272.         if ($aclPerm !== null)
  273.         {
  274.             $acl = $this->aclRepository->findOneBy(array(
  275.                 'function'        =>    $function,
  276.                 'permission'    =>    $aclPerm
  277.             ));
  278.             if ($acl !== null)
  279.             {
  280.                 if ($acl->getValue())
  281.                 {
  282.                     // A single positive answer is enough
  283.                     return true;
  284.                 }
  285.             }
  286.         }
  288.         // If we are here, all hope is lost
  289.         return false;
  290.     }
  292.     private function canDelete(Template $template, Access $access, AccessFunction $function)
  293.     {
  294.         // Do not allow deleting if in use
  295.         $devis = $this->em->getRepository(Devis::class)->findOneByTemplate($template);
  296.         if ($devis !== null)
  297.             return false;
  299.         // Several Acl_Permission exist
  300.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_DELETE);
  302.         // If all are null, exit
  303.         if ($aclPerm === null)
  304.             return false;
  306.         // Get First one (view all)
  307.         if ($aclPerm !== null)
  308.         {
  309.             $acl = $this->aclRepository->findOneBy(array(
  310.                 'function'        =>    $function,
  311.                 'permission'    =>    $aclPerm
  312.             ));
  313.             if ($acl !== null)
  314.             {
  315.                 if ($acl->getValue())
  316.                 {
  317.                     // A single positive answer is enough
  318.                     return true;
  319.                 }
  320.             }
  321.         }
  323.         // If we are here, all hope is lost
  324.         return false;
  325.     }
  327.     private function canDeleteWithProducts(Template $template, Access $access, AccessFunction $function)
  328.     {
  329.         // Do not allow deleting if in use
  330.         $devis = $this->em->getRepository(Devis::class)->findOneByTemplate($template);
  331.         if ($devis !== null)
  332.             return false;
  334.         // Do not allow deleting products if at least one is in use
  335.         foreach ($template->getProducts() as $product) 
  336.         {
  337.             $devisProduct = $this->em->getRepository(DevisProduct::class)->findOneByOriginalProduct($product);
  338.             if ($devisProduct !== null)
  339.                 return false;
  340.             $invoiceProduct = $this->em->getRepository(InvoiceProduct::class)->findOneByOriginalProduct($product);
  341.             if ($invoiceProduct !== null)
  342.                 return false;
  343.         }
  345.         // Several Acl_Permission exist
  346.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_DELETE);
  348.         // If all are null, exit
  349.         if ($aclPerm === null)
  350.             return false;
  352.         // Get First one (view all)
  353.         if ($aclPerm !== null)
  354.         {
  355.             $acl = $this->aclRepository->findOneBy(array(
  356.                 'function'        =>    $function,
  357.                 'permission'    =>    $aclPerm
  358.             ));
  359.             if ($acl !== null)
  360.             {
  361.                 if ($acl->getValue())
  362.                 {
  363.                     // A single positive answer is enough
  364.                     return true;
  365.                 }
  366.             }
  367.         }
  369.         // If we are here, all hope is lost
  370.         return false;
  371.     }
  372. }