gy-doc-code
[ class tree: gy-doc-code ] [ index: gy-doc-code ] [ all elements ]

Source for file AccessUserGroup.php

Documentation is available at AccessUserGroup.php

  1. <?php
  2.  
  3. namespace Gy\Core\User;
  4.  
  5. if (!defined("GY_CORE"&& (GY_CORE !== true)) die"gy: err include core" );
  6.  
  7. /**
  8.  * AccessUserGroup - будет всё что связано с правами доступов пользователей
  9.  * (и групп пользователей)
  10.  */
  11. {
  12.  
  13.     private static $tableNameAccessGroup 'access_group';
  14.     private static $tableNameUserActions 'action_user';
  15.     private static $tableNameUsersInGroupss 'users_in_groups';
  16.  
  17.     private static $cacheTimeGetData 604800;
  18.  
  19.     /**
  20.      * checkAccessUserGroupsByUserAction - определить можно ли пользователю
  21.      *     с заданным набором его групп
  22.      *     и данными по всем группам выполнить указанное действие
  23.      * 
  24.      * @param array $groupsThisUser - группы к каким относится пользователь
  25.      * @param array $dataAllGroups - данные по всем группам
  26.      * @param string $thisAction - проверяемое действие пользователя
  27.      * @return boolean 
  28.      */
  29.     private static function checkAccessUserGroupsByUserAction(
  30.         $groupsThisUser
  31.         $dataAllGroups
  32.         $thisAction
  33.     {
  34.         $arResult false;
  35.  
  36.         // определить все действия разрешённые для данного пользователя
  37.         $AllAccessActionsThisUser array();
  38.         foreach ($groupsThisUser as $nameGroup{
  39.             if ($dataAllGroups[$nameGroup]{
  40.                 $AllAccessActionsThisUser array_merge(
  41.                     $AllAccessActionsThisUser
  42.                     $dataAllGroups[$nameGroup]['code_action_user']
  43.                 );
  44.             }
  45.         }
  46.         
  47.         // найти заданное действие среди разрешённых для данного пользователя
  48.         // либо проверить на админа (т.е. разрешены любые действия)
  49.         if (in_array($thisAction $AllAccessActionsThisUser
  50.             || in_array('action_all' $AllAccessActionsThisUser)
  51.         {
  52.             $arResult true;
  53.         }
  54.         return $arResult;
  55.     }
  56.  
  57.     /**
  58.      * accessUser() - проверит разрешёно ли указанное действие заданному
  59.      *     пользователю
  60.      * 
  61.      * @param int $userId - id пользователя
  62.      * @param string $actionUser - код пользовательского действия
  63.      * @return boolean 
  64.      */
  65.     public static function accessUser($userId$actionUser)
  66.     {
  67.  
  68.         // получить данные по пользователю 
  69.         global $USER;
  70.         $dataUserFind $USER->getUserById($userId);
  71.         
  72.         // получить данные по всем группам
  73.         $dataAllGroups self::getAccessGroup();
  74.         
  75.         // определить пользователю с таким набором групп доступно ли указанное 
  76.         //     действие
  77.         return self::checkAccessUserGroupsByUserAction(
  78.             $dataUserFind['groups']
  79.             $dataAllGroups
  80.             $actionUser
  81.         );
  82.     }
  83.  
  84.     /**
  85.      * accessThisUserByAction - проверить разрешено ли текущему пользователю
  86.      *   указанное действие
  87.      * 
  88.      * @global type $USER 
  89.      * @param string $action - код действия
  90.      * @return boolean 
  91.      */
  92.     public static function accessThisUserByAction($action)
  93.     {
  94.         global $USER;
  95.         $groupsThisUser $USER->getThisUserGroups();
  96.         
  97.         // получить данные по всем группам
  98.         $dataAllGroups self::getAccessGroup();
  99.  
  100.         // определить пользователю с таким набором групп доступно ли указанное 
  101.         //     действие
  102.         $arResult self::checkAccessUserGroupsByUserAction(
  103.             $groupsThisUser
  104.             $dataAllGroups
  105.             $action
  106.         );
  107.  
  108.         return $arResult;
  109.     }
  110.  
  111.     /**
  112.      * getAccessGroup() - получить все группы пользователей какие есть
  113.      *  + вернутся заданные в группах разрешения на пользовательские действия
  114.      * @return array 
  115.      */
  116.     public static function getAccessGroup()
  117.     {
  118.         $arResult array();
  119.  
  120.         global $APP;
  121.         global $CACHE_CLASS_NAME;
  122.         $cache new $CACHE_CLASS_NAME($APP->url);
  123.         $initCache $cache->cacheInit('getAccessGroup'self::$cacheTimeGetData);
  124.  
  125.         if ($initCache{
  126.             $arResult $cache->getCacheData();
  127.         else {
  128.  
  129.             global $DB;
  130.             $res $DB->selectDb(self::$tableNameAccessGrouparray('*'));
  131.             while ($arRes $DB->fetch($res)) {
  132.                 if (!empty($arRes['code_action_user'])) {
  133.                     $arResult[$arRes['code']]['code_action_user'][$arRes['code_action_user']] $arRes['code_action_user'];
  134.                 }
  135.                 $arResult[$arRes['code']]['name'$arRes['name'];
  136.                 $arResult[$arRes['code']]['code'$arRes['code'];
  137.                 $arResult[$arRes['code']]['text'$arRes['text'];
  138.             }
  139.  
  140.             $cache->setCacheData($arResult);
  141.         }
  142.  
  143.         return $arResult;
  144.     }
  145.  
  146.     /**
  147.      * clearCacheForFunctionGetAccessGroup -
  148.      *  сбросить кеш на получение разрешений для групп и всех данных по группам
  149.      * 
  150.      * @global type $APP 
  151.      * @global type $CACHE_CLASS_NAME 
  152.      */
  153.     public static function clearCacheForFunctionGetAccessGroup()
  154.     {
  155.         global $APP;
  156.         global $CACHE_CLASS_NAME;
  157.         $cache new $CACHE_CLASS_NAME($APP->url);
  158.         $cache->cacheInit('getAccessGroup'self::$cacheTimeGetData);
  159.         $cache->clearThisCache();
  160.     }
  161.  
  162.     /**
  163.      * getUserAction() - получить все какие есть пользовательские действия
  164.      * @return array 
  165.      */
  166.     public static function getUserAction()
  167.     {
  168.         $arResult array();
  169.  
  170.         global $APP;
  171.         global $CACHE_CLASS_NAME;
  172.         $cache new $CACHE_CLASS_NAME($APP->url);
  173.         $initCache $cache->cacheInit(
  174.             'getUserAction'
  175.             self::$cacheTimeGetData
  176.         );
  177.  
  178.         if ($initCache{
  179.             $arResult $cache->getCacheData();
  180.         else {
  181.  
  182.             global $DB;
  183.             $res $DB->selectDb(self::$tableNameUserActionsarray('*'));
  184.             while ($arRes $DB->fetch($res)) {
  185.                 $arResult[$arRes['code']]['code'$arRes['code'];
  186.                 $arResult[$arRes['code']]['text'$arRes['text'];
  187.             }
  188.  
  189.             $cache->setCacheData($arResult);
  190.         }
  191.  
  192.         return $arResult;
  193.     }
  194.  
  195.     /**
  196.      * getListGroupsByUser() - получить список групп к каким относится
  197.      *     пользователь
  198.      * 
  199.      * @param int $idUsers - id пользователя
  200.      * @return array 
  201.      */
  202.     public static function getListGroupsByUser($idUsers)
  203.     {
  204.         $arResult array();
  205.  
  206.         // определить id групп к каким относится пользователь
  207.         global $DB;
  208.         $res $DB->selectDb(
  209.             self::$tableNameUsersInGroupss
  210.             array('code_group')
  211.             array('='=>array('id_user'$idUsers ))
  212.         );
  213.         while ($arRes $DB->fetch($res)) {
  214.             $arResult[$arRes['code_group']] $arRes['code_group'];
  215.         }
  216.  
  217.         return $arResult;
  218.     }
  219.  
  220.     /**
  221.      * addUserInGroup() - добавить пользователя в группуы
  222.      * @param int $idUsers - id пользователя
  223.      * @param string $codeGroup - код группы
  224.      * @return boolean 
  225.      */
  226.     public static function addUserInGroup($idUsers$codeGroup)
  227.     {
  228.         $arResult false;
  229.         global $DB;
  230.         $res $DB->insertDb(
  231.             self::$tableNameUsersInGroupss,
  232.             array(
  233.                 'code_group' => $codeGroup,
  234.                 'id_user' => $idUsers,
  235.             )
  236.         );
  237.         if ($res{
  238.             $arResult true;
  239.         }
  240.         return $arResult;
  241.     }
  242.  
  243.     /**
  244.      * deleteUserInAllGroups - удалить пользователя из всех групп
  245.      *  (где он состоит)
  246.      * @param int $idUsers - id пользователя
  247.      * @return boolean 
  248.      */
  249.     public static function deleteUserInAllGroups($idUsers)
  250.     {
  251.         $arResult false;
  252.         global $DB;
  253.         $res $DB->deleteDb(
  254.             self::$tableNameUsersInGroupss
  255.             array('=' => array('id_user'$idUsers)) 
  256.         );
  257.         if ($res{
  258.             $arResult true;
  259.         }
  260.         return $arResult;
  261.     }
  262.  
  263.     /**
  264.      * deleteAllActionsForGroup()
  265.      * - удалить все заданные, разрешённые действия пользователей для указанной
  266.      *      группы
  267.      * 
  268.      * @global type $DB 
  269.      * @param string $codeUserGroup 
  270.      * @return boolean 
  271.      */
  272.     public static function deleteAllActionsForGroup($codeUserGroup)
  273.     {
  274.         $arResult false;
  275.         global $DB;
  276.         $dataAllGroup self::getAccessGroup();
  277.  
  278.         if (!empty($dataAllGroup[$codeUserGroup])) {
  279.             // тут будут данные по нужной группе
  280.             $dataThisGroup $dataAllGroup[$codeUserGroup];
  281.             $dataThisGroup['code_action_user''';
  282.  
  283.             // удаляем все данные по этой группе из БД
  284.             $res $DB->deleteDb(
  285.                 self::$tableNameAccessGroup
  286.                 array(
  287.                     '=' => array(
  288.                         'code'
  289.                         "'".$codeUserGroup."'"
  290.                     )
  291.                 
  292.             );
  293.  
  294.             if ($res{
  295.                 // добавляем пустую группу
  296.                 $res2 $DB->insertDb(
  297.                     self::$tableNameAccessGroup,
  298.                     $dataThisGroup
  299.                 );
  300.                 if ($res2{
  301.                     $arResult true;
  302.                 }
  303.             }
  304.         }
  305.     }
  306.  
  307.     /**
  308.      * addOptionsGroup()
  309.      * - добавить для указанной группы пользователей разрешённое действие
  310.      *  
  311.      * @global type $DB 
  312.      * @param string $codeUserGroup - код группы
  313.      * @param string $codeAction - код пользовательского действия
  314.      * @return boolean 
  315.      */
  316.     public static function addOptionsGroup($codeUserGroup$codeAction)
  317.     {
  318.         $arResult false;
  319.         global $DB;
  320.         $dataAllGroup self::getAccessGroup();
  321.  
  322.         if (!empty($dataAllGroup[$codeUserGroup])) {
  323.             $dataThisGroup $dataAllGroup[$codeUserGroup];
  324.  
  325.             // если действий для пользователя нет обновить группу 
  326.             //     (добавить действия)
  327.             if (empty($dataThisGroup['code_action_user'])) {
  328.                 $dataThisGroup['code_action_user'$codeAction;
  329.                 // если мы попали сюда то всего одна запись в БД соответствует 
  330.                 //     этой группе её и обновляем
  331.                 $res $DB->updateDb(
  332.                     self::$tableNameAccessGroup,
  333.                     $dataThisGroup,
  334.                     array(
  335.                         '=' => array(
  336.                             'code',
  337.                             "'".$codeUserGroup."'"
  338.                         )
  339.                     )
  340.                 );
  341.                 if ($res{
  342.                     $arResult true;
  343.                 }
  344.             else // добавить копию группы с новым действием
  345.                 $dataThisGroup['code_action_user'$codeAction;
  346.                 $res $DB->insertDb(
  347.                     self::$tableNameAccessGroup
  348.                     $dataThisGroup
  349.                 );
  350.                 if ($res{
  351.                     $arResult true;
  352.                 }
  353.             }
  354.  
  355.         }
  356.  
  357.         // сбросить кеш на получение разрешений для групп и всех данных по группам
  358.         self::clearCacheForFunctionGetAccessGroup();
  359.  
  360.         return $arResult;
  361.     }
  362.  
  363.     /**
  364.      * addUserGroup
  365.      *  - добавить новую пользовательскую группу
  366.      * 
  367.      * @global type $DB 
  368.      * @param array $arDataNewGroup - массив с данными по группе (name, code, text)
  369.      * @param array $arActionUserThisGroup - массив с разрешёнными для этой группы
  370.      *      действиями
  371.      * @return boolean 
  372.      */
  373.     public static function addUserGroup($arDataNewGroup$arActionUserThisGroup)
  374.     {
  375.         global $DB;
  376.         $arResult true;
  377.         foreach ($arActionUserThisGroup as $value{
  378.             $res $DB->insertDb(
  379.                 self::$tableNameAccessGroup,
  380.                 array(
  381.                     'code' => $arDataNewGroup['code'],
  382.                     'name' => $arDataNewGroup['name'],
  383.                     'text' => $arDataNewGroup['text'],
  384.                     'code_action_user' => $value
  385.                 )
  386.             );
  387.             if ($res{
  388.                 //$arResult = true;
  389.             else {
  390.                 $arResult false;
  391.             }
  392.         }
  393.  
  394.         // сбросить кеш на получение разрешений для групп и всех данных по группам
  395.         self::clearCacheForFunctionGetAccessGroup();
  396.  
  397.         return $arResult;
  398.     }
  399.  
  400.     /**
  401.      * deleteUserGroupByCode
  402.      *  - удалить пользовательскую группу по коду группы
  403.      * 
  404.      * @global type $DB 
  405.      * @param string $codeGroup - код удаляемой группы
  406.      * @return boolean 
  407.      */
  408.     public static function deleteUserGroupByCode($codeGroup)
  409.     {
  410.         global $DB;
  411.         $arResult false;
  412.         // удалить все связи пользователей с этой группой
  413.  
  414.         $res $DB->deleteDb(
  415.             self::$tableNameUsersInGroupss,
  416.             array('=' => array('code_group' "'".$codeGroup."'" ) )
  417.         );
  418.         if ($res{
  419.             $arResult true;
  420.         }
  421.  
  422.         // удалить группу по коду уруппы
  423.         if ($arResult{
  424.             $arResult false;
  425.             $res $DB->deleteDb(
  426.                 self::$tableNameAccessGroup,
  427.                 array('=' => array('code' "'".$codeGroup."'" ) )
  428.             );
  429.             if ($res{
  430.                 $arResult true;
  431.             }
  432.         }
  433.  
  434.         // сбросить кеш на получение разрешений для групп и всех данных по группам
  435.         self::clearCacheForFunctionGetAccessGroup();
  436.  
  437.         return $arResult;
  438.     }
  439.  
  440. }

Documentation generated on Sat, 27 Apr 2024 11:17:28 +0300 by phpDocumentor 1.4.3