src/Security/InodeVoter.php line 20

Open in your IDE?
  1. <?php
  2. //------------------------------------------------------------------------------
  3. // src/Security/InodeVoter.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\Cloud\Inode;
  13. use App\Entity\Config\Config;
  14. use App\Entity\Config\Module;
  15. use App\Entity\HR\AccessFunction;
  16. use App\Entity\Security\Acl;
  17. use App\Entity\Security\AclPermission;
  18. use App\Services\Config\ModuleTools;
  20. class InodeVoter extends Voter
  21. {
  22.     const IS_ACTIVE = "cloud_is_active";
  24.     const ADD = "add_inode";
  25.     const VIEW = "view_inode";
  26.     const EDIT = "edit_inode";
  27.     const MOVE = "move_inode";
  28.     const SHARE = "share_inode";
  29.     const DELETE = "delete_inode";
  31.     const ACL_PERM_ADD = "inode_add";
  32.     const ACL_PERM_SHARE = "inode_share";
  33.     const ACL_PERM_EDIT_SHARED = "inode_edit_shared";
  34.     const ACL_PERM_DELETE_SHARED = "inode_delete_shared";
  36.     const IS_GRANTED_CONSTANTS = array(
  37.         self::IS_ACTIVE,
  38.         self::ADD,
  39.         self::VIEW,
  40.         self::EDIT,
  41.         self::MOVE,
  42.         self::SHARE,
  43.         self::DELETE,
  44.         self::ACL_PERM_ADD,
  45.         self::ACL_PERM_SHARE,
  46.         self::ACL_PERM_EDIT_SHARED,
  47.         self::ACL_PERM_DELETE_SHARED,
  48.     );
  50.     public function __construct(ManagerRegistry $doctrine, ModuleTools $moduleTools)
  51.     {
  52.         $this->em = $doctrine->getManager();
  53.         $this->moduleTools = $moduleTools;
  55.         $this->aclRepository = $this->em->getRepository(Acl::class);
  56.         $this->aclPermissionRepository = $this->em->getRepository(AclPermission::class);
  57.     }
  59.     // Plan.io Task #4453 [See AccessVoter for details]
  60.     public function supportsAttribute(string $attribute): bool
  61.     {
  62.         return in_array($attribute, self::IS_GRANTED_CONSTANTS, true);
  63.     }
  64.     
  65.     protected function supports(string $attribute, $subject): bool
  66.     {
  67.         // if the attribute isn't one we support, return false
  68.         if (!in_array($attribute, self::IS_GRANTED_CONSTANTS))
  69.         {
  70.             return false;
  71.         }
  73.         // only vote on Inode objects inside this voter
  74.         if ($subject !== null)
  75.         {
  76.             if (!$subject instanceof Inode)
  77.             {
  78.                 return false;
  79.             }
  80.         }
  82.         return true;
  83.     }
  85.     protected function voteOnAttribute(string $attribute, $subject, TokenInterface $token): bool
  86.     {
  87.         $user = $token->getUser();
  89.         if (!$user instanceof Access)
  90.         {
  91.             // the user must be logged in; if not, deny access
  92.             return false;
  93.         }
  95.         // The user must have a function; if not deny access
  96.         $function = $user->getFunction();
  97.         if ($function === null)        return false;
  99.         // Plan.io Task #3710 : Get current group
  100.         $currentGroup = $user->getSocietyGroup();
  101.         if ($currentGroup === null)
  102.             return false;
  104.         // Module activated ?
  105.         if ($this->moduleTools->isInactiveByCode($currentGroup, Module::MODULE_CLOUD))
  106.         {
  107.             return false;
  108.         }
  110.         // you know $subject is a Inode object, thanks to supports
  111.         /** @var Inode $inode */
  112.         $inode = $subject;
  114.         // Check current group affectation
  115.         if ($subject !== null)
  116.         {
  117.             $subjectGroup = $subject->getSocietyGroup();
  118.             if ($subjectGroup === null)
  119.                 return false;
  120.             if (!$currentGroup->equals($subjectGroup))
  121.                 return false;
  122.         }
  124.         switch ($attribute)
  125.         {
  126.             case self::IS_ACTIVE:
  127.                 return true;
  128.             case self::ADD:
  129.                 return $this->canAdd($inode, $user, $function);
  130.             case self::VIEW:
  131.                 return $this->canView($inode, $user, $function);
  132.             case self::EDIT:
  133.                 return $this->canEdit($inode, $user, $function);
  134.             case self::MOVE:
  135.                 return $this->canMove($inode, $user, $function);
  136.             case self::SHARE:
  137.                 return $this->canShare($inode, $user, $function);
  138.             case self::DELETE:
  139.                 return $this->canDelete($inode, $user, $function);
  140.         }
  142.         throw new \LogicException('This code should not be reached!');
  143.     }
  145.     private function canAdd(Inode $inode = null, Access $access, AccessFunction $function)
  146.     {
  147.         // This should not happen
  148.         if ($inode === null)
  149.         {
  150.             // Get AclPermission
  151.             $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_ADD);
  152.             if ($aclPerm === null)        return false;
  154.             // Get Acl
  155.             $acl = $this->aclRepository->findOneBy(array(
  156.                 'function'        =>    $function,
  157.                 'permission'    =>    $aclPerm
  158.             ));
  159.             if ($acl === null)        return false;
  161.             return $acl->getValue();
  162.         }
  164.         // Case 1 : Inode is root or owned by the access
  165.         //     => Check ADD permission from the acl
  166.         if ($inode->isRoot() || $inode->isOwnedBy($access))
  167.         {
  168.             // Get AclPermission
  169.             $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_ADD);
  170.             if ($aclPerm === null)        return false;
  172.             // Get Acl
  173.             $acl = $this->aclRepository->findOneBy(array(
  174.                 'function'        =>    $function,
  175.                 'permission'    =>    $aclPerm
  176.             ));
  177.             if ($acl === null)        return false;
  179.             return $acl->getValue();
  180.         }
  182.         // Case 2 : Inode is not root, and not owned by the access
  183.         //     =>    Check if one of its parents is shared with the access
  184.         // In this case, we need to chekc acl EDIT permission
  186.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_EDIT_SHARED);
  187.         if ($aclPerm === null)        return false;
  189.         // Get Acl
  190.         $acl = $this->aclRepository->findOneBy(array(
  191.             'function'        =>    $function,
  192.             'permission'    =>    $aclPerm
  193.         ));
  194.         if ($acl === null)        return false;
  196.         if ($acl->getValue())
  197.         {
  198.             // The access has permission to edit shared inodes
  199.             return $inode->isSharedWith($access);
  200.         }
  203.         // All hope is lost
  204.         return false;
  205.     }
  207.     private function canShare(Inode $inode = null, Access $access, AccessFunction $function)
  208.     {
  209.         // Get AclPermission
  210.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_SHARE);
  211.         if ($aclPerm === null)        return false;
  213.         // Get Acl
  214.         $acl = $this->aclRepository->findOneBy(array(
  215.             'function'        =>    $function,
  216.             'permission'    =>    $aclPerm
  217.         ));
  218.         if ($acl === null)        return false;
  220.         // Since only one list type can exist for the Inodes,
  221.         // we can return the result of the acl_permission
  222.         return $acl->getValue();
  223.     }
  225.     private function canView(Inode $inode = null, Access $access, AccessFunction $function)
  226.     {
  227.         // All users can view root
  228.         if ($inode->isRoot())
  229.             return true;
  231.         // All user can view own Inodes
  232.         if ($inode->isOwnedBy($access))
  233.             return true;
  235.         // All user can view shared Inodes
  236.         if ($inode->isSharedWith($access))
  237.             return true;
  239.         return false;
  240.     }
  242.     private function canMove(Inode $inode = null, Access $access, AccessFunction $function)
  243.     {
  244.         // Deny for root
  245.         if ($inode->isRoot())
  246.             return false;
  248.         // All user can move own Inodes
  249.         if ($inode->isOwnedBy($access))
  250.             return true;
  252.         // All user can move shared Inodes
  253.         if ($inode->isSharedWith($access))
  254.             return true;
  256.         return false;
  257.     }
  259.     private function canEdit(Inode $inode = null, Access $access, AccessFunction $function)
  260.     {
  261.         if ($inode->isRoot())
  262.             return false;
  264.         // All user can edit own Inodes
  265.         if ($inode->isOwnedBy($access))
  266.             return true;
  268.         // Get AclPermission
  269.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_EDIT_SHARED);
  270.         if ($aclPerm === null)        return false;
  272.         // Get Acl
  273.         $acl = $this->aclRepository->findOneBy(array(
  274.             'function'        =>    $function,
  275.             'permission'    =>    $aclPerm
  276.         ));
  277.         if ($acl === null)        return false;
  279.         if ($acl->getValue())
  280.         {
  281.             // The access has permission to edit shared inodes
  282.             return $inode->isSharedWith($access);
  283.         }
  285.         // All hope is lost
  286.         return false;
  287.     }
  289.     private function canDelete(Inode $inode = null, Access $access, AccessFunction $function)
  290.     {
  291.         if ($inode->isRoot())
  292.             return false;
  294.         // All user can delete own Inodes
  295.         if ($inode->isOwnedBy($access))
  296.             return true;
  298.         // Get AclPermission
  299.         $aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_DELETE_SHARED);
  300.         if ($aclPerm === null)        return false;
  302.         // Get Acl
  303.         $acl = $this->aclRepository->findOneBy(array(
  304.             'function'        =>    $function,
  305.             'permission'    =>    $aclPerm
  306.         ));
  307.         if ($acl === null)        return false;
  309.         if ($acl->getValue())
  310.         {
  311.             // The access has permission to delete shared inodes
  312.             return $inode->isSharedWith($access);
  313.         }
  315.         // All hope is lost
  316.         return false;
  317.     }
  318. }