PHP Cache::clearGroup方法代码示例

 /**
  * Clear Nodes related cache after bulk operation
  *
  * @param CakeEvent $event
  * @return void
  */
 public function onAfterBulkProcess($event)
 {
     Cache::clearGroup('nodes', 'nodes');
     Cache::clearGroup('nodes', 'nodes_view');
     Cache::clearGroup('nodes', 'nodes_promoted');
     Cache::clearGroup('nodes', 'nodes_term');
     Cache::clearGroup('nodes', 'nodes_index');
 }

 /**
  * Delete cache files matching prefix
  *
  * @param object $model
  * @return void
  */
 protected function _deleteCachedFiles(Model $model)
 {
     foreach ($this->settings[$model->alias]['groups'] as $group) {
         $configs = CroogoCache::groupConfigs($group);
         foreach ($configs[$group] as $config) {
             Cache::clearGroup($group, $config);
         }
     }
 }

 /**
  * testLinkIsAllowedByUserId
  */
 public function testLinkIsAllowedByUserId()
 {
     Cache::clearGroup('acl', 'permissions');
     $resetUrl = 'controllers/Users/reset';
     $nodeViewUrl = 'controllers/Nodes/view';
     $result = $this->AclHelper->linkIsAllowedByUserId(3, $nodeViewUrl);
     $this->assertTrue($result);
     $result = $this->AclHelper->linkIsAllowedByUserId(3, $resetUrl);
     $this->assertTrue($result);
     $result = $this->AclHelper->linkIsAllowedByUserId(2, $nodeViewUrl);
     $this->assertTrue($result);
     $result = $this->AclHelper->linkIsAllowedByUserId(2, $resetUrl);
     $this->assertTrue($result);
 }

 /**
  * Test clearing a cache group
  *
  * @return void
  */
 public function testGroupClear()
 {
     Cache::config('redis_groups', array('engine' => 'Redis', 'duration' => 3600, 'groups' => array('group_a', 'group_b')));
     $this->assertTrue(Cache::write('test_groups', 'value', 'redis_groups'));
     $this->assertTrue(Cache::clearGroup('group_a', 'redis_groups'));
     $this->assertFalse(Cache::read('test_groups', 'redis_groups'));
     $this->assertTrue(Cache::write('test_groups', 'value2', 'redis_groups'));
     $this->assertTrue(Cache::clearGroup('group_b', 'redis_groups'));
     $this->assertFalse(Cache::read('test_groups', 'redis_groups'));
 }

 /**
  * Test clearing a cache group
  *
  * @return void
  */
 public function testGroupClear()
 {
     Cache::config('wincache_groups', array('engine' => 'Wincache', 'duration' => 0, 'groups' => array('group_a', 'group_b'), 'prefix' => 'test_'));
     $this->assertTrue(Cache::write('test_groups', 'value', 'wincache_groups'));
     $this->assertTrue(Cache::clearGroup('group_a', 'wincache_groups'));
     $this->assertFalse(Cache::read('test_groups', 'wincache_groups'));
     $this->assertTrue(Cache::write('test_groups', 'value2', 'wincache_groups'));
     $this->assertTrue(Cache::clearGroup('group_b', 'wincache_groups'));
     $this->assertFalse(Cache::read('test_groups', 'wincache_groups'));
 }

 /**
  * Test that clearGroup works with no prefix.
  *
  * @return void
  */
 public function testGroupClearNoPrefix()
 {
     Cache::config('file_groups', array('engine' => 'File', 'duration' => 3600, 'prefix' => '', 'groups' => array('group_a', 'group_b')));
     Cache::write('key_1', 'value', 'file_groups');
     Cache::write('key_2', 'value', 'file_groups');
     Cache::clearGroup('group_a', 'file_groups');
     $this->assertFalse(Cache::read('key_1', 'file_groups'), 'Did not delete');
     $this->assertFalse(Cache::read('key_2', 'file_groups'), 'Did not delete');
 }

 /**
  *
  * @param AclNode $aro_nodes The Aro model hierarchy
  * @param string $aco_path The Aco path to check for
  * @param string $permission_type 'deny' or 'allow', 'grant', depending on what permission (grant or deny) is being set
  */
 public function save_permission($aro_nodes, $aco_path, $permission_type)
 {
     //debug($aro_nodes);debug($aco_path);debug($permission_type);
     if (isset($aro_nodes[0])) {
         $aco_path = 'controllers/' . $aco_path;
         $pk_name = 'id';
         if ($aro_nodes[0]['Aro']['model'] == Configure::read('acl.aro.role.model')) {
             $pk_name = $this->controller->_get_role_primary_key_name();
         } elseif ($aro_nodes[0]['Aro']['model'] == Configure::read('acl.aro.user.model')) {
             $pk_name = $this->controller->_get_user_primary_key_name();
         }
         //clear acl cache
         Cache::clearGroup('acl', Configure::read('CacheDbAclConfig'));
         $aro_model_data = array($aro_nodes[0]['Aro']['model'] => array($pk_name => $aro_nodes[0]['Aro']['foreign_key']));
         $aro_id = $aro_nodes[0]['Aro']['id'];
         $specific_permission_right = $this->get_specific_permission_right($aro_nodes[0], $aco_path);
         $inherited_permission_right = $this->get_first_parent_permission_right($aro_nodes[0], $aco_path);
         if (!isset($inherited_permission_right) && count($aro_nodes) > 1) {
             /*
              * Get the permission inherited by the parent ARO
              */
             $specific_parent_aro_permission_right = $this->get_specific_permission_right($aro_nodes[1], $aco_path);
             if (isset($specific_parent_aro_permission_right)) {
                 /*
                  * If there is a specific permission for the parent ARO on the ACO, the child ARO inheritates this permission
                  */
                 $inherited_permission_right = $specific_parent_aro_permission_right;
             } else {
                 $inherited_permission_right = $this->get_first_parent_permission_right($aro_nodes[1], $aco_path);
             }
         }
         /*
          * Check if the specific permission is necessary to get the correct permission
          */
         if (!isset($inherited_permission_right)) {
             $specific_permission_needed = true;
         } else {
             if ($permission_type == 'allow' || $permission_type == 'grant') {
                 $specific_permission_needed = $inherited_permission_right != 1;
             } else {
                 $specific_permission_needed = $inherited_permission_right == 1;
             }
         }
         if ($specific_permission_needed) {
             if ($permission_type == 'allow' || $permission_type == 'grant') {
                 if ($this->Acl->allow($aro_model_data, $aco_path)) {
                     return true;
                 } else {
                     trigger_error(__d('acl', 'An error occured while saving the specific permission'), E_USER_NOTICE);
                     return false;
                 }
             } else {
                 if ($this->Acl->deny($aro_model_data, $aco_path)) {
                     return true;
                 } else {
                     trigger_error(__d('acl', 'An error occured while saving the specific permission'), E_USER_NOTICE);
                     return false;
                 }
             }
         } elseif (isset($specific_permission_right)) {
             $aco_node = $this->Acl->Aco->node($aco_path);
             if (!empty($aco_node)) {
                 $aco_id = $aco_node[0]['Aco']['id'];
                 $specific_permission = $this->Acl->Aro->Permission->find('first', array('conditions' => array('aro_id' => $aro_id, 'aco_id' => $aco_id)));
                 if (!empty($specific_permission)) {
                     if ($this->Acl->Aro->Permission->delete(array('Permission.id' => $specific_permission['Permission']['id']))) {
                         return true;
                     } else {
                         trigger_error(__d('acl', 'An error occured while deleting the specific permission'), E_USER_NOTICE);
                         return false;
                     }
                 } else {
                     /*
                      * As $specific_permission_right has a value, we should never fall here, but who knows... ;-)
                      */
                     trigger_error(__d('acl', 'The specific permission id could not be retrieved'), E_USER_NOTICE);
                     return false;
                 }
             } else {
                 /*
                  * As $specific_permission_right has a value, we should never fall here, but who knows... ;-)
                  */
                 trigger_error(__d('acl', 'The child ACO id could not be retrieved'), E_USER_NOTICE);
                 return false;
             }
         } else {
             /*
              * Right can be inherited, and no specific permission exists => there is nothing to do...
              */
         }
     } else {
         trigger_error(__d('acl', 'Invalid ARO'), E_USER_NOTICE);
         return false;
     }
//.........这里部分代码省略.........

 /**
  * Test clearing a cache group
  *
  * @return void
  */
 public function testGroupClear()
 {
     Cache::config('file_groups', array('engine' => 'File', 'duration' => 3600, 'groups' => array('group_a', 'group_b')));
     Cache::config('file_groups2', array('engine' => 'File', 'duration' => 3600, 'groups' => array('group_b')));
     Cache::config('file_groups3', array('engine' => 'File', 'duration' => 3600, 'groups' => array('group_a')));
     $this->assertTrue(Cache::write('test_groups', 'value', 'file_groups'));
     $this->assertTrue(Cache::write('test_groups2', 'value', 'file_groups2'));
     $this->assertTrue(Cache::write('test_groups3', 'value', 'file_groups3'));
     $this->assertTrue(Cache::clearGroup('group_a', 'file_groups'));
     $this->assertFalse(Cache::read('test_groups', 'file_groups'));
     $this->assertEquals('value', Cache::read('test_groups2', 'file_groups2'));
     $this->assertFalse(Cache::read('test_groups3', 'file_groups3'));
     $this->assertTrue(Cache::write('test_groups4', 'value', 'file_groups'));
     $this->assertTrue(Cache::write('test_groups5', 'value', 'file_groups2'));
     $this->assertTrue(Cache::write('test_groups6', 'value', 'file_groups3'));
     $this->assertTrue(Cache::clearGroup('group_b', 'file_groups'));
     $this->assertFalse(Cache::read('test_groups4', 'file_groups'));
     $this->assertFalse(Cache::read('test_groups5', 'file_groups2'));
     $this->assertEquals('value', Cache::read('test_groups6', 'file_groups3'));
 }

 /**
  * Admin movedown
  *
  * @param integer $id
  * @param integer $step
  * @return void
  * @access public
  */
 public function admin_movedown($id, $step = 1)
 {
     $link = $this->Link->findById($id);
     if (!isset($link['Link']['id'])) {
         $this->Session->setFlash(__d('croogo', 'Invalid id for Link'), 'default', array('class' => 'error'));
         $this->redirect(array('controller' => 'menus', 'action' => 'index'));
     }
     $this->__scopeTreeToMenu($link['Link']['menu_id']);
     if ($this->Link->moveDown($id, $step)) {
         Cache::clearGroup('menus', 'croogo_menus');
         $this->Session->setFlash(__d('croogo', 'Moved down successfully'), 'default', array('class' => 'success'));
     } else {
         $this->Session->setFlash(__d('croogo', 'Could not move down'), 'default', array('class' => 'error'));
     }
     $this->redirect(array('action' => 'index', '?' => array('menu_id' => $link['Link']['menu_id'])));
 }

 /**
  * afterDelete
  */
 public function afterDelete(Model $model)
 {
     Cache::clearGroup('acl', 'permissions');
 }

 /**
  * Updates the Aco Tree with new controller actions.
  *
  * @return void
  **/
 public function aco_update($params = array())
 {
     $root = $this->_checkNode($this->rootNode, $this->rootNode, null);
     if (empty($params['plugin'])) {
         $controllers = $this->getControllerList();
         $this->_updateControllers($root, $controllers);
         $plugins = CakePlugin::loaded();
     } else {
         $plugin = $params['plugin'];
         if (!in_array($plugin, App::objects('plugin')) || !CakePlugin::loaded($plugin)) {
             $this->err(__d('croogo', '<error>Plugin %s not found or not activated</error>', $plugin));
             return false;
         }
         $plugins = array($params['plugin']);
     }
     foreach ($plugins as $plugin) {
         $controllers = $this->getControllerList($plugin);
         $path = $this->rootNode . '/' . $plugin;
         $pluginRoot = $this->_checkNode($path, $plugin, $root['Aco']['id']);
         $this->_updateControllers($pluginRoot, $controllers, $plugin);
         $this->_updateApiComponents($controllers, $plugin);
     }
     Cache::clearGroup('acl', 'permissions');
     if ($this->_clean) {
         $this->out(__d('croogo', '<success>Aco Sync Complete</success>'));
     } else {
         $this->out(__d('croogo', '<success>Aco Update Complete</success>'));
     }
     return true;
 }

 public function afterSave($created, $options = array())
 {
     Cache::clearGroup('admin_menus', 'admin_menus');
 }

 /**
  * afterSave
  */
 public function afterSave($created, $options = array())
 {
     Cache::clearGroup('acl', 'permissions');
 }

 /**
  * Clear Links related cache after bulk operation
  *
  * @param CakeEvent $event
  * @return void
  */
 public function onAfterBulkProcess($event)
 {
     Cache::clearGroup('menus', 'croogo_menus');
 }

 /**
  * afterDelete Callback
  *
  * Invalidates the cache group for this model.
  *
  * @param Model $model Model the callback was run on.
  * @return void
  */
 public function afterDelete(Model $model)
 {
     $cacheGroupName = $this->runtime[$model->alias]['default_cache'];
     $cacheName = $cacheGroupName;
     Cache::clearGroup($cacheGroupName, $cacheName);
 }