Merge branch '2014.11-develop' into 2015.11
[tine20] / tine20 / Tinebase / Container.php
1 <?php
2 /**
3  * Tine 2.0
4  * 
5  * @package     Tinebase
6  * @subpackage  Container
7  * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
8  * @copyright   Copyright (c) 2007-2012 Metaways Infosystems GmbH (http://www.metaways.de)
9  * @author      Lars Kneschke <l.kneschke@metaways.de>
10  * 
11  * @todo        refactor that: remove code duplication, remove Zend_Db_Table_Abstract usage, use standard record controller/backend functions
12  *              -> make use of Tinebase_Backend_Sql_Grants
13  * @todo        move (or replace from) functions to backend
14  * @todo        switch containers to hash ids
15  */
16
17 /**
18  * this class handles access rights(grants) to containers
19  * 
20  * any record in Tine 2.0 is tied to a container. the rights of an account on a record gets 
21  * calculated by the grants given to this account on the container holding the record (if you know what i mean ;-))
22  * 
23  * @package     Tinebase
24  * @subpackage  Acl
25  */
26 class Tinebase_Container extends Tinebase_Backend_Sql_Abstract
27 {
28     /**
29      * Table name without prefix
30      *
31      * @var string
32      */
33     protected $_tableName = 'container';
34     
35     /**
36      * Model name
37      *
38      * @var string
39      */
40     protected $_modelName = 'Tinebase_Model_Container';
41     
42     /**
43      * if modlog is active, we add 'is_deleted = 0' to select object in _getSelect()
44      *
45      * @var boolean
46      */
47     protected $_modlogActive = TRUE;
48     
49     /**
50      * the table object for the container_acl table
51      *
52      * @var Zend_Db_Table_Abstract
53      */
54     protected $_containerAclTable;
55     
56     /**
57      * container content history backend
58      * 
59      * @var Tinebase_Backend_Sql
60      */
61     protected $_contentBackend = NULL;
62     
63     /**
64      * don't clone. Use the singleton.
65      *
66      */
67     private function __clone() {}
68     
69     /**
70      * holds the instance of the singleton
71      *
72      * @var Tinebase_Container
73      */
74     private static $_instance = NULL;
75     
76     /**
77      * default column(s) for count
78      *
79      * @var string
80      */
81     protected $_defaultCountCol = 'id';
82     
83     /**
84      * cache timeout for ACL related cache entries (in seconds)
85      * 
86      * @see 0007266: make groups / group memberships cache cleaning more efficient
87      * @var integer
88      */
89     const ACL_CACHE_TIMEOUT = 30;
90     
91     /**
92      * the singleton pattern
93      *
94      * @return Tinebase_Container
95      */
96     public static function getInstance() 
97     {
98         if (self::$_instance === NULL) {
99             self::$_instance = new Tinebase_Container();
100         }
101         
102         return self::$_instance;
103     }
104     
105     /**
106      * get content backend
107      * 
108      * @return Tinebase_Backend_Sql
109      * 
110      * @todo move this to constructor when this no longer extends Tinebase_Backend_Sql_Abstract
111      */
112     public function getContentBackend()
113     {
114         if ($this->_contentBackend === NULL) {
115             $this->_contentBackend  = new Tinebase_Backend_Sql(array(
116                 'modelName' => 'Tinebase_Model_ContainerContent', 
117                 'tableName' => 'container_content',
118             ));
119         }
120         
121         return $this->_contentBackend;
122     }
123     
124     /**
125      * creates a new container
126      *
127      * @param   Tinebase_Model_Container $_container the new container
128      * @param   Tinebase_Record_RecordSet $_grants the grants for the new folder 
129      * @param   bool  $_ignoreAcl
130      * @return  Tinebase_Model_Container the newly created container
131      * @throws  Tinebase_Exception_Record_Validation
132      * @throws  Tinebase_Exception_AccessDenied
133      */
134     public function addContainer(Tinebase_Model_Container $_container, $_grants = NULL, $_ignoreAcl = FALSE)
135     {
136         $_container->isValid(TRUE);
137         
138         if ($_ignoreAcl !== TRUE) {
139             switch ($_container->type) {
140                 case Tinebase_Model_Container::TYPE_PERSONAL:
141                     // is the user allowed to create personal container?
142                     break;
143                     
144                 case Tinebase_Model_Container::TYPE_SHARED:
145                     $application = Tinebase_Application::getInstance()->getApplicationById($_container->application_id);
146                     $appName = (string) $application;
147                     $manageRight = FALSE;
148                     
149                     // check for MANAGE_SHARED_FOLDERS right
150                     $appAclClassName = $appName . '_Acl_Rights';
151                     if (@class_exists($appAclClassName)) {
152                         $appAclObj = call_user_func(array($appAclClassName, 'getInstance'));
153                         $allRights = $appAclObj->getAllApplicationRights();
154                         if (in_array(Tinebase_Acl_Rights::MANAGE_SHARED_FOLDERS, $allRights)) {
155                             $manageRight = Tinebase_Core::getUser()->hasRight($appName, Tinebase_Acl_Rights::MANAGE_SHARED_FOLDERS);
156                         }
157                     }
158                     
159
160                     if(!$manageRight && !Tinebase_Core::getUser()->hasRight($appName, Tinebase_Acl_Rights::ADMIN)) {
161                         throw new Tinebase_Exception_AccessDenied('Permission to add shared container denied.');
162                     }
163                     break;
164                     
165                 default:
166                     throw new Tinebase_Exception_InvalidArgument('Can add personal or shared folders only when ignoring ACL.');
167                     break;
168             }
169         }
170         
171         if (!empty($_container->owner_id)) {
172             $accountId = $_container->owner_id instanceof Tinebase_Model_User ? $_container->owner_id->getId() : $_container->owner_id;
173         } else {
174             $accountId = (is_object(Tinebase_Core::getUser())) ? Tinebase_Core::getUser()->getId() : NULL;
175         }
176         
177         if($_grants === NULL || count($_grants) == 0) {
178             $creatorGrants = array(
179                 'account_id'     => $accountId,
180                 'account_type'   => Tinebase_Acl_Rights::ACCOUNT_TYPE_USER,
181                 Tinebase_Model_Grants::GRANT_READ      => true,
182                 Tinebase_Model_Grants::GRANT_ADD       => true,
183                 Tinebase_Model_Grants::GRANT_EDIT      => true,
184                 Tinebase_Model_Grants::GRANT_DELETE    => true,
185                 Tinebase_Model_Grants::GRANT_EXPORT    => true,
186                 Tinebase_Model_Grants::GRANT_SYNC      => true,
187                 Tinebase_Model_Grants::GRANT_ADMIN     => true,
188             );
189             
190             if (    $_container->type === Tinebase_Model_Container::TYPE_SHARED 
191                  && ! Tinebase_Config::getInstance()->get(Tinebase_Config::ANYONE_ACCOUNT_DISABLED)) {
192     
193                 // add all grants to creator and
194                 // add read grants to any other user
195                 $grants = new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(
196                     $creatorGrants,
197                     array(
198                         'account_id'      => '0',
199                         'account_type'    => Tinebase_Acl_Rights::ACCOUNT_TYPE_ANYONE,
200                         Tinebase_Model_Grants::GRANT_READ    => true,
201                         Tinebase_Model_Grants::GRANT_EXPORT  => true,
202                         Tinebase_Model_Grants::GRANT_SYNC    => true,
203                     )
204                 ), TRUE);
205             } else {
206                 // add all grants to creator only
207                 $grants = new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(
208                     $creatorGrants
209                 ), TRUE);
210             }
211         } else {
212             $grants = $_grants;
213         }
214         
215         $event = new Tinebase_Event_Container_BeforeCreate();
216         $event->accountId = $accountId;
217         $event->container = $_container;
218         $event->grants = $grants;
219         Tinebase_Event::fireEvent($event);
220         
221         Tinebase_Timemachine_ModificationLog::setRecordMetaData($_container, 'create');
222         $container = $this->create($_container);
223         $this->setGrants($container->getId(), $grants, TRUE, FALSE);
224         
225         return $container;
226     }
227     
228     /**
229      * add grants to container
230      *
231      * @todo    check that grant is not already given to container/type/accout combi
232      * @param   int|Tinebase_Model_Container $_containerId
233      * @param   int $_accountId
234      * @param   array $_grants list of grants to add
235      * @return  boolean
236      * @throws  Tinebase_Exception_AccessDenied
237      */
238     public function addGrants($_containerId, $_accountType, $_accountId, array $_grants, $_ignoreAcl = FALSE)
239     {
240         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
241         
242         if($_ignoreAcl !== TRUE and !$this->hasGrant(Tinebase_Core::getUser(), $_containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
243             throw new Tinebase_Exception_AccessDenied('Permission to manage grants on container denied.');
244         }
245         
246         switch($_accountType) {
247             case Tinebase_Acl_Rights::ACCOUNT_TYPE_USER:
248                 $accountId = Tinebase_Model_User::convertUserIdToInt($_accountId);
249                 break;
250             case Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP:
251                 $accountId = Tinebase_Model_Group::convertGroupIdToInt($_accountId);
252                 break;
253             case Tinebase_Acl_Rights::ACCOUNT_TYPE_ANYONE:
254                 $accountId = '0';
255                 break;
256             default:
257                 throw new Tinebase_Exception_InvalidArgument('invalid $_accountType');
258                 break;
259         }
260         
261         $containerGrants = $this->getGrantsOfContainer($containerId, TRUE);
262         $containerGrants->addIndices(array('account_type', 'account_id'));
263         $existingGrants = $containerGrants->filter('account_type', $_accountType)->filter('account_id', $_accountId)->getFirstRecord();
264         
265         $id = Tinebase_Record_Abstract::generateUID();
266         
267         foreach($_grants as $grant) {
268             if ($existingGrants === NULL || ! $existingGrants->{$grant}) {
269                 $data = array(
270                     'id'            => $id,
271                     'container_id'  => $containerId,
272                     'account_type'  => $_accountType,
273                     'account_id'    => $accountId,
274                     'account_grant' => $grant
275                 );
276                 $this->_getContainerAclTable()->insert($data);
277             }
278         }
279         
280         $this->_setRecordMetaDataAndUpdate($containerId, 'update');
281         
282         return true;
283     }
284     
285     /**
286      * resolves the $_recordClass argument for legacy handling: $_recordClass was before $_application
287      * in getDefaultContainer and getPersonalContainer
288      * @param string|Tinebase_Record_Interface $_recordClass
289      * @throws Tinebase_Exception_InvalidArgument
290      */
291     protected function _resolveRecordClassArgument($_recordClass)
292     {
293         $ret = array();
294         if(is_string($_recordClass)) {
295             $split = explode('_', $_recordClass);
296             switch(count($split)) {
297                 case 1:
298                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' Using application name is deprecated. Please use the classname of the model or the class itself.');
299                     $ret['appName'] = $_recordClass;
300                     if(! $ret['recordClass'] = Tinebase_Core::getApplicationInstance($_recordClass)->getDefaultModel()) {
301                         throw new Tinebase_Exception_NotFound('A default model could not be found for application ' . $_recordClass);
302                     }
303                     break;
304                 case 3: 
305                     $ret['appName'] = $split[0];
306                     $ret['recordClass'] = $_recordClass;
307                     break;
308                 default: throw new Tinebase_Exception_InvalidArgument('Invalid value as recordClass given: ' . print_r($_recordClass, 1));
309             }
310         } elseif (in_array('Tinebase_Record_Interface', class_implements($_recordClass))) {
311             $ret['appName'] = $_recordClass->getApplication();
312             $ret['recordClass'] = get_class($_recordClass);
313         } else {
314             throw new Tinebase_Exception_InvalidArgument('Invalid value as recordClass given: ' . print_r($_recordClass, 1));
315         }
316         
317         return $ret;
318     }
319     
320     /**
321      * set modified timestamp for container
322      * 
323      * @param int|Tinebase_Model_Container $container
324      * @param string                       $action    one of {create|update|delete}
325      * @return Tinebase_Model_Container
326      */
327     protected function _setRecordMetaDataAndUpdate($container, $action)
328     {
329         if (! $container instanceof Tinebase_Model_Container) {
330             $container = $this->getContainerById($container);
331         }
332         Tinebase_Timemachine_ModificationLog::getInstance()->setRecordMetaData($container, $action, $container);
333         
334         $this->_clearCache($container);
335         
336         return $this->update($container);
337     }
338     
339     /**
340     * get the basic select object to fetch records from the database
341     *
342     * @param array|string $_cols columns to get, * per default
343     * @param boolean $_getDeleted get deleted records (if modlog is active)
344     * @return Zend_Db_Select
345     */
346     protected function _getSelect($_cols = '*', $_getDeleted = FALSE)
347     {
348         $select = parent::_getSelect($_cols, $_getDeleted);
349         
350         if ($_cols === '*') {
351             $select->joinLeft(
352                 /* table  */ array('owner' => SQL_TABLE_PREFIX . 'container_acl'),
353                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('container.id')} AND ".
354                              "{$this->_db->quoteIdentifier('container.type')} = {$this->_db->quote(Tinebase_Model_Container::TYPE_PERSONAL)} AND " .
355                              "{$this->_db->quoteIdentifier('owner.account_type')} = {$this->_db->quote('user')} AND " .
356                              "{$this->_db->quoteIdentifier('owner.account_grant')} = {$this->_db->quote(Tinebase_Model_Grants::GRANT_ADMIN)}",
357                 /* select */ array('owner_id' => 'account_id')
358             );
359         }
360         
361         return $select;
362     }
363     
364     /**
365      * get containers with bad names (name == uuid)
366      * 
367      * @return Tinebase_Record_RecordSet
368      */
369     public function getContainersWithBadNames()
370     {
371         $select = $this->_getSelect();
372         $select->where($this->_db->quoteIdentifier('uuid') . ' = ' . $this->_db->quoteIdentifier('name'));
373         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
374         $rows = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
375         
376         $result = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $rows, TRUE);
377         
378         return $result;
379     }
380     
381     /**
382      * return all container, which the user has the requested right for
383      *
384      * used to get a list of all containers accesssible by the current user
385      * 
386      * @param   string|Tinebase_Model_User          $accountId
387      * @param   string|Tinebase_Model_Application   $recordClass
388      * @param   array|string                        $grant
389      * @param   bool                                $onlyIds return only ids
390      * @param   bool                                $ignoreACL
391      * @return  Tinebase_Record_RecordSet|array
392      * @throws  Tinebase_Exception_NotFound
393      */
394     public function getContainerByACL($accountId, $recordClass, $grant, $onlyIds = FALSE, $ignoreACL = FALSE)
395     {
396         // legacy handling 
397         $meta = $this->_resolveRecordClassArgument($recordClass);
398         
399         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
400             . ' app: ' . $meta['appName'] . ' / account: ' . $accountId . ' / grant:' . implode('/', (array)$grant));
401         
402         $accountId     = Tinebase_Model_User::convertUserIdToInt($accountId);
403         $applicationId = Tinebase_Application::getInstance()->getApplicationByName($meta['appName'])->getId();
404         $grant         = $ignoreACL ? '*' : $grant;
405         
406         // always bring values in the same order for $classCacheId 
407         if (is_array($grant)) {
408             sort($grant);
409         }
410         
411         $classCacheId = $accountId . $applicationId . implode('', (array)$grant) . (int)$onlyIds . (int)$ignoreACL;
412         
413         try {
414             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
415         } catch (Tinebase_Exception_NotFound $tenf) {
416             // continue...
417         }
418         
419         $select = $this->_getSelect($onlyIds ? 'id' : '*')
420             ->distinct()
421             ->join(array(
422                 /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
423                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
424                 /* select */ array()
425             )
426             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $applicationId);
427             
428         if (!$onlyIds) {
429             // we only need to order by name if we fetch all container data (legacy, maybe this can be removed)
430             $select->order('container.name');
431         }
432         
433         $this->addGrantsSql($select, $accountId, $grant);
434         
435         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
436         
437         if ($onlyIds) {
438             $result = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
439         } else {
440             $result = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $stmt->fetchAll(Zend_Db::FETCH_ASSOC), true);
441         }
442         
443         // any account should have at least one personal folder
444         // @todo add test for empty case
445         if (empty($result)) {
446             $personalContainer = $this->getDefaultContainer($meta['appName'], $accountId);
447             if ($personalContainer instanceof Tinebase_Model_Container) {
448                 $result = ($onlyIds) ? 
449                     array($personalContainer->getId()) : 
450                     new Tinebase_Record_RecordSet('Tinebase_Model_Container', array($personalContainer), TRUE);
451             }
452         }
453         
454         $this->saveInClassCache(__FUNCTION__, $classCacheId, $result);
455         
456         return $result;
457     }
458     
459     /**
460      * return a container by containerId
461      * - cache the results because this function is called very often
462      *
463      * @todo what about grant checking here???
464      * 
465      * @param   int|Tinebase_Model_Container $_containerId the id of the container
466      * @param   bool                         $_getDeleted get deleted records
467      * @return  Tinebase_Model_Container
468      * @throws  Tinebase_Exception_NotFound
469      */
470     public function getContainerById($_containerId, $_getDeleted = FALSE)
471     {
472         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
473         
474         $cacheId = $containerId . 'd' . (int)$_getDeleted;
475         
476         try {
477             return $this->loadFromClassCache(__FUNCTION__, $cacheId, Tinebase_Cache_PerRequest::VISIBILITY_SHARED);
478         } catch (Tinebase_Exception_NotFound $tenf) {
479             // continue...
480         }
481         
482         $result = $this->get($containerId, $_getDeleted);
483         
484         $this->saveInClassCache(__FUNCTION__, $cacheId, $result, Tinebase_Cache_PerRequest::VISIBILITY_SHARED);
485         
486         return $result;
487     }
488     
489     /**
490      * return a container identified by path
491      *
492      * @param   string  $_path        the path to the container
493      * @param   bool    $_getDeleted  get deleted records
494      * @return  Tinebase_Model_Container
495      * @throws  Tinebase_Exception_NotFound
496      */
497     public function getByPath($_path, $_getDeleted = FALSE)
498     {
499         if (($containerId = Tinebase_Model_Container::pathIsContainer($_path) === false)) {
500             throw new Tinebase_Exception_UnexpectedValue ("Invalid path $_path supplied.");
501         }
502     
503         return $this->getContainerById($containerId, $_getDeleted);
504     }
505     
506     /**
507      * return a container by container name
508      *
509      * @param   string|Tinebase_Model_Application  $recordClass app name
510      * @param   int|Tinebase_Model_Container       $containerName
511      * @param   string                             $type
512      * @param   string                             $ownerId
513      * @return  Tinebase_Model_Container
514      * @throws  Tinebase_Exception_NotFound
515      * @throws  Tinebase_Exception_UnexpectedValue
516      */
517     public function getContainerByName($recordClass, $containerName, $type, $ownerId = NULL)
518     {
519         // legacy handling
520         $meta = $this->_resolveRecordClassArgument($recordClass);
521         
522         if (! in_array($type, array(Tinebase_Model_Container::TYPE_PERSONAL, Tinebase_Model_Container::TYPE_SHARED))) {
523             throw new Tinebase_Exception_UnexpectedValue ("Invalid type $type supplied.");
524         }
525         
526         if ($type == Tinebase_Model_Container::TYPE_PERSONAL && empty($ownerId)) {
527             throw new Tinebase_Exception_UnexpectedValue ('$ownerId can not be empty for personal folders');
528         }
529         
530         $ownerId = $ownerId instanceof Tinebase_Model_User ? $ownerId->getId() : $ownerId;
531         
532         $applicationId = Tinebase_Application::getInstance()->getApplicationByName($meta['appName'])->getId();
533
534         $select = $this->_getSelect()
535             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $applicationId)
536             ->where("{$this->_db->quoteIdentifier('container.name')} = ?", $containerName)
537             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", $type)
538             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE);
539
540         if ($type == Tinebase_Model_Container::TYPE_PERSONAL) {
541             $select->where("{$this->_db->quoteIdentifier('owner.account_id')} = ?", $ownerId);
542         }
543         
544         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
545         $containersData = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
546         
547         if (count($containersData) == 0) {
548             throw new Tinebase_Exception_NotFound("Container $containerName not found.");
549         }
550         if (count($containersData) > 1) {
551             throw new Tinebase_Exception_Duplicate("Container $containerName name duplicate.");
552         }
553
554         $container = new Tinebase_Model_Container($containersData[0]);
555         
556         return $container;
557     }
558     
559     /**
560      * returns the personal container of a given account accessible by a another given account
561      *
562      * @param   string|Tinebase_Model_User          $_accountId
563      * @param   string|Tinebase_Record_Interface    $_recordClass
564      * @param   int|Tinebase_Model_User             $_owner
565      * @param   array|string                        $_grant
566      * @param   bool                                $_ignoreACL
567      * @return  Tinebase_Record_RecordSet of subtype Tinebase_Model_Container
568      * @throws  Tinebase_Exception_NotFound
569      */
570     public function getPersonalContainer($_accountId, $_recordClass, $_owner, $_grant = Tinebase_Model_Grants::GRANT_READ, $_ignoreACL = false)
571     {
572         $meta = $this->_resolveRecordClassArgument($_recordClass);
573         
574         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
575         $ownerId     = Tinebase_Model_User::convertUserIdToInt($_owner);
576         $grant       = $_ignoreACL ? '*' : $_grant;
577         $application = Tinebase_Application::getInstance()->getApplicationByName($meta['appName']);
578         
579         $classCacheId = $accountId .
580                         $application->getId() .
581                         ($meta['recordClass'] ? $meta['recordClass'] : null) .
582                         $ownerId .
583                         implode('', (array)$grant) .
584                         (int)$_ignoreACL;
585         
586         try {
587             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
588         } catch (Tinebase_Exception_NotFound $tenf) {
589             // continue...
590         }
591         
592         $select = $this->_db->select()
593             ->distinct()
594             ->from(array('owner' => SQL_TABLE_PREFIX . 'container_acl'), array())
595             ->join(array(
596                 /* table  */ 'user' => SQL_TABLE_PREFIX . 'container_acl'), 
597                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('user.container_id')}",
598                 /* select */ array()
599             )
600             ->join(array(
601                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
602                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('container.id')}"
603             )
604             
605             ->where("{$this->_db->quoteIdentifier('owner.account_id')} = ?", $ownerId)
606             ->where("{$this->_db->quoteIdentifier('owner.account_grant')} = ?", Tinebase_Model_Grants::GRANT_ADMIN)
607             
608             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
609             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_PERSONAL)
610             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE)
611             
612             ->order('container.name');
613             
614         $this->addGrantsSql($select, $accountId, $grant, 'user');
615         
616         if ($meta['recordClass']) {
617             $select->where("{$this->_db->quoteIdentifier('container.model')} = ?", $meta['recordClass']);
618         }
619         
620         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
621         $containersData = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
622
623         // if no containers where found, maybe something went wrong when creating the initial folder
624         // let's check if the controller of the application has a function to create the needed folders
625         if (empty($containersData) && $accountId === $ownerId) {
626             $application = Tinebase_Core::getApplicationInstance($meta['appName']);
627
628             if ($application instanceof Tinebase_Container_Interface && method_exists($application, 'createPersonalFolder')) {
629                 return $application->createPersonalFolder($accountId);
630             } else if ($meta['recordClass']) {
631                 $containersData = array($this->createDefaultContainer($meta['recordClass'], $meta['appName'], $accountId));
632             }
633         }
634
635         $containers = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $containersData, TRUE);
636
637         $this->saveInClassCache(__FUNCTION__, $classCacheId, $containers);
638
639         return $containers;
640     }
641
642     /**
643      * create default container for a user
644      *
645      * @param string $recordClass
646      * @param string $applicationName
647      * @param Tinebase_Model_User|string $account
648      * @param string $containerName
649      * @return Tinebase_Model_Container
650      * @throws Tinebase_Exception_AccessDenied
651      * @throws Tinebase_Exception_InvalidArgument
652      * @throws Tinebase_Exception_NotFound
653      *
654      * @todo add record name to container name?
655      */
656     public function createDefaultContainer($recordClass, $applicationName, $account, $containerName = null)
657     {
658         if (! $account instanceof Tinebase_Model_User) {
659             $account = Tinebase_User::getInstance()->getUserByPropertyFromSqlBackend('accountId', $account);
660         }
661
662         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
663             . ' Creating new default container ' . $containerName . ' for '
664             . $account->accountFullName . ' for model ' . $recordClass);
665
666         if (! $containerName) {
667             $translation = Tinebase_Translation::getTranslation('Tinebase');
668             $containerName = sprintf($translation->_("%s's personal container"), $account->accountFullName);
669         }
670
671         $container = $this->addContainer(new Tinebase_Model_Container(array(
672             'name'              => $containerName,
673             'type'              => Tinebase_Model_Container::TYPE_PERSONAL,
674             'owner_id'          => $account->getId(),
675             'backend'           => 'Sql',
676             'model'             => $recordClass,
677             'application_id'    => Tinebase_Application::getInstance()->getApplicationByName($applicationName)->getId()
678         )));
679
680         return $container;
681     }
682     
683     /**
684      * appends container_acl sql 
685      * 
686      * @param  Zend_Db_Select    $_select
687      * @param  String            $_accountId
688      * @param  Array|String      $_grant
689      * @param  String            $_aclTableName
690      * @param  bool              $_andGrants
691      * @return void
692      */
693     public static function addGrantsSql($_select, $_accountId, $_grant, $_aclTableName = 'container_acl', $_andGrants = FALSE, $joinCallBack = NULL)
694     {
695         $accountId = $_accountId instanceof Tinebase_Record_Abstract
696             ? $_accountId->getId()
697             : $_accountId;
698         
699         $db = $_select->getAdapter();
700         
701         $grants = is_array($_grant) ? $_grant : array($_grant);
702
703         $groupMemberships   = Tinebase_Group::getInstance()->getGroupMemberships($accountId);
704         
705         $quotedActId   = $db->quoteIdentifier("{$_aclTableName}.account_id");
706         $quotedActType = $db->quoteIdentifier("{$_aclTableName}.account_type");
707         
708         $accountSelect = new Tinebase_Backend_Sql_Filter_GroupSelect($_select);
709         $accountSelect
710             ->orWhere("{$quotedActId} = ? AND {$quotedActType} = " . $db->quote(Tinebase_Acl_Rights::ACCOUNT_TYPE_USER), $accountId)
711             ->orWhere("{$quotedActId} IN (?) AND {$quotedActType} = " . $db->quote(Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP), empty($groupMemberships) ? ' ' : $groupMemberships);
712         
713         if (! Tinebase_Config::getInstance()->get(Tinebase_Config::ANYONE_ACCOUNT_DISABLED)) {
714             $accountSelect->orWhere("{$quotedActType} = ?", Tinebase_Acl_Rights::ACCOUNT_TYPE_ANYONE);
715         }
716         $accountSelect->appendWhere(Zend_Db_Select::SQL_AND);
717         
718         // we only need to filter, if the filter does not contain %
719         if (!in_array('*', $grants)) {
720             // @todo fetch wildcard from specific db adapter
721             $grants = str_replace('*', '%', $grants);
722         
723             $quotedGrant   = $db->quoteIdentifier($_aclTableName . '.account_grant');
724
725             $iteration = 0;
726             $grantsSelect = new Tinebase_Backend_Sql_Filter_GroupSelect($_select);
727             foreach ($grants as $grant) {
728                 if ($_andGrants) {
729                     if ($iteration > 0) {
730                         $callbackIdentifier = call_user_func($joinCallBack, $_select, $iteration);
731                         $grantsSelect->where($db->quoteIdentifier($callbackIdentifier . '.account_grant') . ' LIKE ?', $grant);
732                     } else {
733                         $grantsSelect->where($quotedGrant . ' LIKE ?', $grant);
734                     }
735                     ++$iteration;
736                 } else {
737                     $grantsSelect->orWhere($quotedGrant . ' LIKE ?', $grant);
738                 }
739             }
740
741             // admin grant includes all other grants
742             if (! in_array(Tinebase_Model_Grants::GRANT_ADMIN, $grants)) {
743                 $grantsSelect->orWhere($quotedGrant . ' LIKE ?', Tinebase_Model_Grants::GRANT_ADMIN);
744             }
745
746             $grantsSelect->appendWhere(Zend_Db_Select::SQL_AND);
747         }
748     }
749
750     /**
751      * gets default container of given user for given app
752      *  - did and still does return personal first container by using the application name instead of the recordClass name
753      *  - allows now to use different models with default container in one application
754      *
755      * @param   string|Tinebase_Record_Interface    $recordClass
756      * @param   string|Tinebase_Model_User          $accountId
757      * @param   string                              $defaultContainerPreferenceName
758      * @return  Tinebase_Model_Container
759      * 
760      * @todo get default container name from app/translations?
761      */
762     public function getDefaultContainer($recordClass, $accountId = NULL, $defaultContainerPreferenceName = NULL)
763     {
764         // legacy handling
765         $meta = $this->_resolveRecordClassArgument($recordClass);
766         
767         if ($defaultContainerPreferenceName !== NULL) {
768             $defaultContainerId = Tinebase_Core::getPreference($meta['appName'])->getValue($defaultContainerPreferenceName);
769             try {
770                 $result = $this->getContainerById($defaultContainerId);
771                 Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
772                     . ' Got default container from preferences: ' . $result->name);
773                 return $result;
774             } catch (Tinebase_Exception $te) {
775                 Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__ . ' Default container not found (' . $te->getMessage() . ')');
776                 // default may be gone -> remove default adb pref
777                 $appPref = Tinebase_Core::getPreference($meta['appName']);
778                 if ($appPref) {
779                     $appPref->deleteUserPref($defaultContainerPreferenceName);
780                 }
781             }
782         }
783         
784         $account = ($accountId !== NULL)
785             ? Tinebase_User::getInstance()->getUserByPropertyFromSqlBackend('accountId', $accountId)
786             : Tinebase_Core::getUser();
787         $result = $this->getPersonalContainer($account, $recordClass, $account, Tinebase_Model_Grants::GRANT_ADD)->getFirstRecord();
788         
789         if ($result === NULL) {
790             $result = $this->createDefaultContainer($recordClass, $meta['appName'], $accountId);
791         }
792         
793         if ($defaultContainerPreferenceName !== NULL) {
794             // save as new pref
795             Tinebase_Core::getPreference($meta['appName'])->setValue($defaultContainerPreferenceName, $result->getId());
796         }
797
798         return $result;
799     }
800     
801     /**
802      * returns the shared container for a given application accessible by the current user
803      *
804      * @param   string|Tinebase_Model_User          $_accountId
805      * @param   string|Tinebase_Model_Application   $recordClass
806      * @param   array|string                        $_grant
807      * @param   bool                                $_ignoreACL
808      * @param   bool                                $_andGrants
809      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_Container
810      * @throws  Tinebase_Exception_NotFound
811      */
812     public function getSharedContainer($_accountId, $recordClass, $_grant, $_ignoreACL = FALSE, $_andGrants = FALSE)
813     {
814         // legacy handling
815         $meta = $this->_resolveRecordClassArgument($recordClass);
816         $application = Tinebase_Application::getInstance()->getApplicationByName($meta['appName']);
817         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
818         $grant       = $_ignoreACL ? '*' : $_grant;
819         
820         $classCacheId = Tinebase_Helper::convertCacheId(
821             $accountId .
822             $application->getId() .
823             implode('', (array)$grant) .
824             (int)$_ignoreACL .
825             (int)$_andGrants
826         );
827
828         try {
829             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
830         } catch (Tinebase_Exception_NotFound $tenf) {
831             // continue...
832         }
833         
834         $select = $this->_getSelect()
835             ->distinct()
836             ->join(array(
837                 /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
838                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
839                 array()
840             )
841             
842             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
843             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_SHARED)
844             
845             ->order('container.name');
846         
847         $this->addGrantsSql($select, $accountId, $grant, 'container_acl', $_andGrants, __CLASS__ . '::addGrantsSqlCallback');
848         
849         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
850         
851         $containers = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $stmt->fetchAll(Zend_Db::FETCH_ASSOC), TRUE);
852         
853         $this->saveInClassCache(__FUNCTION__, $classCacheId, $containers);
854         
855         Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
856             . ' Found ' . count($containers) . ' shared container(s) in application ' . $application->name);
857         
858         return $containers;
859     }
860     
861     /**
862      * return users which made personal containers accessible to given account
863      *
864      * @param   string|Tinebase_Model_User          $_accountId
865      * @param   string|Tinebase_Model_Application   $recordClass
866      * @param   array|string                        $_grant
867      * @param   bool                                $_ignoreACL
868      * @param   bool                                $_andGrants
869      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_User
870      */
871     public function getOtherUsers($_accountId, $recordClass, $_grant, $_ignoreACL = FALSE, $_andGrants = FALSE)
872     {
873         $meta = $this->_resolveRecordClassArgument($recordClass);
874         $userIds = $this->_getOtherAccountIds($_accountId, $meta['appName'], $_grant, $_ignoreACL, $_andGrants);
875         
876         $users = Tinebase_User::getInstance()->getMultiple($userIds);
877         $users->sort('accountDisplayName');
878         
879         return $users;
880     }
881
882     /**
883      * appends container_acl sql
884      *
885      * @param  Zend_Db_Select    $_select
886      * @param  integer           $iteration
887      * @return string table identifier to work on
888      */
889     public static function addGrantsSqlCallback($_select, $iteration)
890     {
891         $db = $_select->getAdapter();
892         $_select->join(array(
893             /* table  */ 'container_acl' . $iteration => SQL_TABLE_PREFIX . 'container_acl'),
894             /* on     */ $db->quoteIdentifier('container_acl' . $iteration . '.container_id') . ' = ' . $db->quoteIdentifier('container.id'),
895             array()
896         );
897         return 'container_acl' . $iteration;
898     }
899
900     /**
901      * return account ids of accounts which made personal container accessible to given account
902      *
903      * @param   string|Tinebase_Model_User          $_accountId
904      * @param   string|Tinebase_Model_Application   $_application
905      * @param   array|string                        $_grant
906      * @param   bool                                $_ignoreACL
907      * @param   bool                                $_andGrants
908      * @return  array of array of containerData
909      */
910     protected function _getOtherAccountIds($_accountId, $_application, $_grant, $_ignoreACL = FALSE, $_andGrants = FALSE)
911     {
912         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
913         $application = Tinebase_Application::getInstance()->getApplicationByName($_application);
914         $grant       = $_ignoreACL ? '*' : $_grant;
915
916         $classCacheId = Tinebase_Helper::convertCacheId($accountId . $application->getId() . implode('', (array)$grant) . (int)$_ignoreACL . (int)$_andGrants);
917         try {
918             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
919         } catch (Tinebase_Exception_NotFound $tenf) {
920             // continue...
921         }
922
923         // first grab all container ids ...
924         $select = $this->_db->select()
925             ->distinct()
926             ->from(array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'), array())
927             ->join(array(
928                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
929                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
930                 /* select */ array('container_id' => 'container.id')
931             )
932             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
933             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_PERSONAL)
934             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE);
935
936         $this->addGrantsSql($select, $accountId, $grant, 'container_acl', $_andGrants, __CLASS__ . '::addGrantsSqlCallback');
937
938         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
939         $containerIds = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
940         
941         // no container ids found / can stop here
942         if (empty($containerIds)) {
943             return $containerIds;
944         }
945         
946         // ... now get the owners of the containers 
947         $select = $this->_db->select()
948             ->distinct()
949             ->from(array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'), array('account_id'))
950             ->join(array(
951                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
952                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
953                 /* select */ array()
954             )
955             ->join(array(
956                 /* table  */ 'accounts' => SQL_TABLE_PREFIX . 'accounts'),
957                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.account_id')} = {$this->_db->quoteIdentifier('accounts.id')}",
958                 /* select */ array()
959             )
960             ->where("{$this->_db->quoteIdentifier('container.id')} IN (?)", $containerIds)
961             ->where("{$this->_db->quoteIdentifier('container_acl.account_id')} != ?", $accountId)
962             ->where("{$this->_db->quoteIdentifier('container_acl.account_grant')} = ?", Tinebase_Model_Grants::GRANT_ADMIN)
963             ->where("{$this->_db->quoteIdentifier('accounts.status')} = ?", 'enabled');
964             
965         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
966         $accountIds = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
967
968         $this->saveInClassCache(__FUNCTION__, $classCacheId, $accountIds);
969         
970         return $accountIds;
971     }
972     
973     /**
974      * return set of all personal container of other users made accessible to the given account 
975      *
976      * @param   string|Tinebase_Model_User          $_accountId
977      * @param   string|Tinebase_Model_Application   $recordClass
978      * @param   array|string                        $_grant
979      * @param   bool                                $_ignoreACL
980      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_Container
981      */
982     public function getOtherUsersContainer($_accountId, $recordClass, $_grant, $_ignoreACL = FALSE)
983     {
984         // legacy handling
985         $meta = $this->_resolveRecordClassArgument($recordClass);
986         $result = $this->_getOtherUsersContainerData($_accountId, $meta['appName'], $_grant, $_ignoreACL);
987
988         return $result;
989     }
990     
991     /**
992      * return containerData of containers which made personal accessible to given account
993      *
994      * @param   string|Tinebase_Model_User          $_accountId
995      * @param   string|Tinebase_Model_Application   $_application
996      * @param   array|string                        $_grant
997      * @param   bool                                $_ignoreACL
998      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_Container
999      */
1000     protected function _getOtherUsersContainerData($_accountId, $_application, $_grant, $_ignoreACL = FALSE)
1001     {
1002         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
1003         $application = Tinebase_Application::getInstance()->getApplicationByName($_application);
1004         $grant       = $_ignoreACL ? '*' : $_grant;
1005         
1006         $classCacheId = $accountId .
1007                         $application->getId() .
1008                         implode('', (array)$grant) .
1009                         (int)$_ignoreACL;
1010         
1011         try {
1012             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
1013         } catch (Tinebase_Exception_NotFound $tenf) {
1014             // continue...
1015         }
1016         
1017         $select = $this->_db->select()
1018             ->from(array('owner' => SQL_TABLE_PREFIX . 'container_acl'), array('account_id'))
1019             ->join(array(
1020                 /* table  */ 'user' => SQL_TABLE_PREFIX . 'container_acl'), 
1021                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('user.container_id')}",
1022                 /* select */ array()
1023             )
1024             ->join(array(
1025                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
1026                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('container.id')}"
1027             )
1028             ->join(array(
1029                 /* table  */ 'accounts' => SQL_TABLE_PREFIX . 'accounts'),
1030                 /* on     */ "{$this->_db->quoteIdentifier('owner.account_id')} = {$this->_db->quoteIdentifier('accounts.id')}",
1031                 /* select */ array()
1032             )
1033             #->join(array(
1034             #    /* table  */ 'contacts' => SQL_TABLE_PREFIX . 'addressbook'),
1035             #    /* on     */ "{$this->_db->quoteIdentifier('owner.account_id')} = {$this->_db->quoteIdentifier('contacts.account_id')}",
1036             #    /* select */ array()
1037             #)
1038             ->where("{$this->_db->quoteIdentifier('owner.account_id')} != ?", $accountId)
1039             ->where("{$this->_db->quoteIdentifier('owner.account_grant')} = ?", Tinebase_Model_Grants::GRANT_ADMIN)
1040             
1041             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
1042             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_PERSONAL)
1043             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE)
1044             ->where("{$this->_db->quoteIdentifier('accounts.status')} = ?", 'enabled')
1045             
1046             ->order('accounts.display_name')
1047             ->group('owner.account_id');
1048         
1049         $this->addGrantsSql($select, $accountId, $grant, 'user');
1050         
1051         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1052         
1053         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1054         
1055         $containers = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $stmt->fetchAll(Zend_Db::FETCH_ASSOC), TRUE);
1056
1057         $this->saveInClassCache(__FUNCTION__, $classCacheId, $containers);
1058         
1059         return $containers;
1060     }
1061     
1062     /**
1063      * delete container if user has the required right
1064      *
1065      * @param   int|Tinebase_Model_Container $_containerId
1066      * @param   boolean $_ignoreAcl
1067      * @param   boolean $_tryAgain
1068      * @throws  Tinebase_Exception_AccessDenied
1069      * @throws  Tinebase_Exception_Record_SystemContainer
1070      * @throws  Tinebase_Exception_InvalidArgument
1071      * 
1072      * @todo move records in deleted container to personal container?
1073      */
1074     public function deleteContainer($_containerId, $_ignoreAcl = FALSE, $_tryAgain = TRUE)
1075     {
1076         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1077         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($containerId);
1078         $this->checkSystemContainer($containerId);
1079         
1080         $tm = Tinebase_TransactionManager::getInstance();   
1081         $myTransactionId = $tm->startTransaction(Tinebase_Core::getDb());
1082
1083         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1084             . ' Deleting container id ' . $containerId . ' ...');
1085
1086         $deletedContainer = NULL;
1087         
1088         try {
1089             if($_ignoreAcl !== TRUE) {
1090                 if(!$this->hasGrant(Tinebase_Core::getUser(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1091                     throw new Tinebase_Exception_AccessDenied('Permission to delete container denied.');
1092                 }
1093                 
1094                 if($container->type !== Tinebase_Model_Container::TYPE_PERSONAL and $container->type !== Tinebase_Model_Container::TYPE_SHARED) {
1095                     throw new Tinebase_Exception_InvalidArgument('Can delete personal or shared containers only.');
1096                 }
1097             }
1098             $this->deleteContainerContents($container, $_ignoreAcl);
1099             $deletedContainer = $this->_setRecordMetaDataAndUpdate($container, 'delete');
1100             
1101         } catch (Exception $e) {
1102             $tm->rollBack();
1103             throw $e;
1104         }
1105         
1106         $tm->commitTransaction($myTransactionId);
1107         
1108         return $deletedContainer;
1109         /*
1110         // move all contained objects to next available personal container and try again to delete container
1111         $app = Tinebase_Application::getApplicationById($container->application_id);
1112
1113         // get personal containers
1114         $personalContainers = $this->getPersonalContainer(
1115             Tinebase_Core::getUser(),
1116             $app->name,
1117             $container->owner,
1118             Tinebase_Model_Grants::GRANT_ADD
1119         );
1120         
1121         //-- determine first matching personal container (or create new one)
1122         // $personalContainer =
1123         
1124         //-- move all records to personal container
1125         
1126         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1127             . ' Moving all records from container ' . $containerId . ' to personal container ' . $personalContainer->getId()
1128         );
1129         */
1130     }
1131     
1132     /**
1133      * set delete flag of records belonging to the given container
1134      * 
1135      * @param Tinebase_Model_Container $container
1136      */
1137     public function deleteContainerContents($container, $_ignoreAcl = FALSE)
1138     {
1139         // set records belonging to this container to deleted
1140         $model = $container->model;
1141
1142         if (empty($model)) {
1143             Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1144                 . ' No container model defined');
1145             return;
1146         }
1147
1148         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1149             . ' Deleting container contents ...');
1150
1151         $controller = Tinebase_Core::getApplicationInstance($model);
1152         $filterName = $model . 'Filter';
1153
1154         if ($_ignoreAcl === TRUE && method_exists($controller, 'doContainerACLChecks')) {
1155             $acl = $controller->doContainerACLChecks(FALSE);
1156         }
1157         if ($controller && class_exists($filterName)) {
1158             $filter = new $filterName(array(
1159                 array(
1160                     'field'    => 'container_id',
1161                     'operator' => 'equals',
1162                     'value'    => intval($container->id)
1163                 ),
1164                 array(
1165                     'field'    => 'is_deleted',
1166                     'operator' => 'equals',
1167                     'value'    => 0
1168                 )),
1169                 'AND');
1170             $controller::getInstance()->deleteByFilter($filter);
1171         }
1172
1173         if ($_ignoreAcl === TRUE && method_exists($controller, 'doContainerACLChecks')) {
1174             $controller->doContainerACLChecks($acl);
1175         }
1176     }
1177     
1178     /**
1179      * delete container by application id
1180      * 
1181      * @param string $_applicationId
1182      * @return integer numer of deleted containers 
1183      */
1184     public function deleteContainerByApplicationId($_applicationId)
1185     {
1186         $this->resetClassCache();
1187         
1188         return $this->deleteByProperty($_applicationId, 'application_id');
1189     }
1190     
1191     /**
1192      * set container name, if the user has the required right
1193      *
1194      * @param   int|Tinebase_Model_Container $_containerId
1195      * @param   string $_containerName the new name
1196      * @return  Tinebase_Model_Container
1197      * @throws  Tinebase_Exception_AccessDenied
1198      */
1199     public function setContainerName($_containerId, $_containerName)
1200     {
1201         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1202         
1203         if (!$this->hasGrant(Tinebase_Core::getUser(), $container, Tinebase_Model_Grants::GRANT_ADMIN)) {
1204             throw new Tinebase_Exception_AccessDenied('Permission to rename container denied.');
1205         }
1206         
1207         $container->name = $_containerName;
1208         
1209         return $this->_setRecordMetaDataAndUpdate($container, 'update');
1210     }
1211     
1212     /**
1213      * set container color, if the user has the required right
1214      *
1215      * @param   int|Tinebase_Model_Container $_containerId
1216      * @param   string $_color the new color
1217      * @return  Tinebase_Model_Container
1218      * @throws  Tinebase_Exception_AccessDenied
1219      */
1220     public function setContainerColor($_containerId, $_color)
1221     {
1222         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1223
1224         if (! $this->hasGrant(Tinebase_Core::getUser(), $container, Tinebase_Model_Grants::GRANT_ADMIN)) {
1225             throw new Tinebase_Exception_AccessDenied('Permission to set color of container denied.');
1226         }
1227         
1228         if (! preg_match('/^#[0-9a-fA-F]{6}$/', $_color)) {
1229             throw new Tinebase_Exception_UnexpectedValue('color is not valid');
1230         }
1231         
1232         $container->color = $_color;
1233         
1234         return $this->_setRecordMetaDataAndUpdate($container, 'update');
1235     }
1236     
1237     /**
1238      * check if the given user user has a certain grant
1239      *
1240      * @param   string|Tinebase_Model_User          $_accountId
1241      * @param   int|Tinebase_Model_Container        $_containerId
1242      * @param   array|string                        $_grant
1243      * @return  boolean
1244      */
1245     public function hasGrant($_accountId, $_containerId, $_grant)
1246     {
1247         $accountId = Tinebase_Model_User::convertUserIdToInt($_accountId);
1248         
1249         try {
1250             $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1251         } catch (Tinebase_Exception_InvalidArgument $teia) {
1252             if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__ . ' ' . $teia->getMessage());
1253             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' ' . $teia->getTraceAsString());
1254             return false;
1255         }
1256         
1257         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1258             . ' account: ' . $accountId . ' / containerId: ' . $containerId . ' / grant:' . implode('/', (array)$_grant));
1259         
1260         $classCacheId = $accountId . $containerId . implode('', (array)$_grant);
1261         
1262         try {
1263             $allGrants = $this->loadFromClassCache(__FUNCTION__, $classCacheId);
1264         } catch (Tinebase_Exception_NotFound $tenf) {
1265             // NOTE: some tests ask for already deleted container ;-)
1266             $select = $this->_getSelect(array(), true)
1267                 ->distinct()
1268                 ->where("{$this->_db->quoteIdentifier('container.id')} = ?", $containerId)
1269                 ->join(array(
1270                     /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
1271                     /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
1272                     /* select */ array('container_acl.account_grant')
1273                 );
1274                 
1275             $this->addGrantsSql($select, $accountId, '*');
1276             
1277             $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1278             
1279             $allGrants = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
1280             $this->saveInClassCache(__FUNCTION__, $classCacheId, $allGrants);
1281         }
1282         
1283         $matchingGrants = array_intersect((array)$_grant, $allGrants);
1284         
1285         return !!count($matchingGrants);
1286     }
1287     
1288     /**
1289      * get all grants assigned to this container
1290      *
1291      * @param   int|Tinebase_Model_Container $_containerId
1292      * @param   bool                         $_ignoreAcl
1293      * @param   string                       $_grantModel
1294      * @return  Tinebase_Record_RecordSet subtype Tinebase_Model_Grants
1295      * @throws  Tinebase_Exception_AccessDenied
1296      */
1297     public function getGrantsOfContainer($_containerId, $_ignoreAcl = FALSE, $_grantModel = 'Tinebase_Model_Grants') 
1298     {
1299         $grants = new Tinebase_Record_RecordSet('Tinebase_Model_Grants');
1300         
1301         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1302         
1303         $select = $this->_getAclSelectByContainerId($containerId)
1304             ->group(array('container_acl.container_id', 'container_acl.account_type', 'container_acl.account_id'));
1305         
1306         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1307         
1308         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1309
1310         $grantsData = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1311         
1312         foreach($grantsData as $grantData) {
1313             $givenGrants = explode(',', $grantData['account_grants']);
1314             foreach($givenGrants as $grant) {
1315                 $grantData[$grant] = TRUE;
1316             }
1317             
1318             $containerGrant = new $_grantModel($grantData, TRUE);
1319
1320             $grants->addRecord($containerGrant);
1321         }
1322         
1323         if ($_ignoreAcl !== TRUE) {
1324             if (TRUE !== $this->hasGrant(Tinebase_Core::getUser()->getId(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1325                 throw new Tinebase_Exception_AccessDenied('Permission to get grants of container denied.');
1326             }
1327         }
1328         return $grants;
1329     }
1330     
1331     /**
1332      * get select with acl (grants) by container ID
1333      * 
1334      * @param integer $containerId
1335      * @return Zend_Db_Select
1336      */
1337     protected function _getAclSelectByContainerId($containerId)
1338     {
1339          $select = $this->_db->select()
1340             ->from(
1341                 array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'),
1342                 array('*', 'account_grants' => $this->_dbCommand->getAggregate('container_acl.account_grant'))
1343             )
1344             ->where("{$this->_db->quoteIdentifier('container_acl.container_id')} = ?", $containerId);
1345          return $select;
1346     }
1347     
1348     /**
1349      * get grants assigned to one account of one container
1350      *
1351      * @param   string|Tinebase_Model_User          $_accountId
1352      * @param   int|Tinebase_Model_Container        $_containerId
1353      * @param   string                              $_grantModel
1354      * @return Tinebase_Model_Grants
1355      */
1356     public function getGrantsOfAccount($_accountId, $_containerId, $_grantModel = 'Tinebase_Model_Grants') 
1357     {
1358         $accountId          = Tinebase_Model_User::convertUserIdToInt($_accountId);
1359         $containerId        = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1360         $container          = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1361         
1362         $classCacheId = $accountId . $containerId . $container->seq . $_grantModel;
1363         
1364         try {
1365             return $this->loadFromClassCache(__FUNCTION__, $classCacheId, Tinebase_Cache_PerRequest::VISIBILITY_SHARED);
1366         } catch (Tinebase_Exception_NotFound $tenf) {
1367             
1368         }
1369         
1370         $select = $this->_getAclSelectByContainerId($containerId)
1371             ->group('container_acl.account_grant');
1372         
1373         $this->addGrantsSql($select, $accountId, '*');
1374         
1375         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1376         
1377         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1378         
1379         $rows = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1380         
1381         $grants = $this->_getGrantsFromArray($rows, $accountId, $_grantModel);
1382         
1383         $this->saveInClassCache(__FUNCTION__, $classCacheId, $grants, Tinebase_Cache_PerRequest::VISIBILITY_SHARED, self::ACL_CACHE_TIMEOUT);
1384         
1385         return $grants;
1386     }
1387     
1388     /**
1389      * get grants assigned to given account of multiple records
1390      *
1391      * @param   Tinebase_Record_RecordSet   $_records records to get the grants for
1392      * @param   string|Tinebase_Model_User  $_accountId the account to get the grants for
1393      * @param   string                      $_containerProperty container property
1394      * @param   string                      $_grantModel
1395      * @throws  Tinebase_Exception_NotFound
1396      */
1397     public function getGrantsOfRecords(Tinebase_Record_RecordSet $_records, $_accountId, $_containerProperty = 'container_id', $_grantModel = 'Tinebase_Model_Grants')
1398     {
1399         $containers = $this->getContainerGrantsOfRecords($_records, $_accountId, $_containerProperty, $_grantModel);
1400         
1401         if (!$containers) {
1402             return;
1403         }
1404         
1405         // add container & grants to records
1406         foreach ($_records as &$record) {
1407             if (!$containerId = $record->$_containerProperty) {
1408                 continue;
1409             }
1410             
1411             if (! is_array($containerId) && ! $containerId instanceof Tinebase_Record_Abstract && isset($containers[$containerId])) {
1412                 if (isset($containers[$containerId]->path)) {
1413                     $record->$_containerProperty = $containers[$containerId];
1414                 } else {
1415                     // if path is not determinable, skip this container
1416                     // @todo is it correct to remove record from recordSet???
1417                     $_records->removeRecord($record);
1418                 }
1419             }
1420         }
1421     }
1422     
1423     /**
1424      * get grants for containers assigned to given account of multiple records
1425      *
1426      * @param   Tinebase_Record_RecordSet   $_records records to get the grants for
1427      * @param   string|Tinebase_Model_User  $_accountId the account to get the grants for
1428      * @param   string                      $_containerProperty container property
1429      * @param   string                      $_grantModel
1430      * @throws  Tinebase_Exception_NotFound
1431      * @return  array of containers|void
1432      */
1433     public function getContainerGrantsOfRecords(Tinebase_Record_RecordSet $_records, $_accountId, $_containerProperty = 'container_id', $_grantModel = 'Tinebase_Model_Grants')
1434     {
1435         $containerIds = array();
1436         foreach ($_records as $record) {
1437             if (isset($record[$_containerProperty]) && !isset($containerIds[Tinebase_Model_Container::convertContainerIdToInt($record[$_containerProperty])])) {
1438                 $containerIds[Tinebase_Model_Container::convertContainerIdToInt($record[$_containerProperty])] = null;
1439             }
1440         }
1441         
1442         if (empty($containerIds)) {
1443             return array();
1444         }
1445         
1446         $accountId = $_accountId instanceof Tinebase_Record_Abstract
1447             ? $_accountId->getId()
1448             : $_accountId;
1449         
1450         $select = $this->_getSelect('*', TRUE)
1451             ->where("{$this->_db->quoteIdentifier('container.id')} IN (?)", array_keys($containerIds))
1452             ->join(array(
1453                 /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
1454                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
1455                 /* select */ array('*', 'account_grants' => $this->_dbCommand->getAggregate('container_acl.account_grant'))
1456             )
1457             ->group('container.id', 'container_acl.account_type', 'container_acl.account_id');
1458             
1459         $this->addGrantsSql($select, $accountId, '*');
1460         
1461         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1462         
1463         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1464         $rows = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1465         
1466         $containers = array();
1467         // add results to container ids and get grants array
1468         foreach ($rows as $row) {
1469             // NOTE id is non-ambiguous
1470             $row['id']   = $row['container_id'];
1471             
1472             $grantsArray = array_unique(explode(',', $row['account_grants']));
1473             $row['account_grants'] = $this->_getGrantsFromArray($grantsArray, $accountId, $_grantModel)->toArray();
1474             
1475             $containers[$row['id']] = new Tinebase_Model_Container($row, TRUE);
1476             
1477             try {
1478                 $containers[$row['id']]->path = $containers[$row['id']]->getPath();
1479             } catch (Exception $e) {
1480                 // @todo is it correct to catch all exceptions here?
1481                 Tinebase_Exception::log($e);
1482             }
1483         }
1484         
1485         return $containers;
1486     }
1487     
1488     /**
1489      * set all grants for given container
1490      *
1491      * @param   int|Tinebase_Model_Container $_containerId
1492      * @param   Tinebase_Record_RecordSet $_grants
1493      * @param   boolean $_ignoreAcl
1494      * @param   boolean $_failSafe don't allow to remove all admin grants for container
1495      * @return  Tinebase_Record_RecordSet subtype Tinebase_Model_Grants
1496      * @throws  Tinebase_Exception_AccessDenied
1497      * @throws  Tinebase_Exception_Backend
1498      * @throws  Tinebase_Exception_Record_NotAllowed
1499      */
1500     public function setGrants($_containerId, Tinebase_Record_RecordSet $_grants, $_ignoreAcl = FALSE, $_failSafe = TRUE) 
1501     {
1502         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1503         
1504         if($_ignoreAcl !== TRUE) {
1505             if(!$this->hasGrant(Tinebase_Core::getUser(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1506                 throw new Tinebase_Exception_AccessDenied('Permission to set grants of container denied.');
1507             }
1508         }
1509         
1510         // do failsafe check
1511         if ($_failSafe) {
1512             $adminGrant = FALSE;
1513             foreach ($_grants as $recordGrants) {
1514                 if ($recordGrants->{Tinebase_Model_Grants::GRANT_ADMIN}) {
1515                     $adminGrant = TRUE;
1516                 }
1517             }
1518             if (count($_grants) == 0 || ! $adminGrant) {
1519                 throw new Tinebase_Exception_UnexpectedValue('You are not allowed to remove all (admin) grants for this container.');
1520             }
1521         }
1522         
1523         if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__ . ' Setting grants for container id ' . $containerId . ' ...');
1524         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ . ' ' . print_r($_grants->toArray(), TRUE));
1525         
1526         try {
1527
1528             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction(Tinebase_Core::getDb());
1529             
1530             $where = $this->_getContainerAclTable()->getAdapter()->quoteInto($this->_db->quoteIdentifier('container_id') . ' = ?', $containerId);
1531             $this->_getContainerAclTable()->delete($where);
1532             
1533             foreach ($_grants as $recordGrants) {
1534                 $data = array(
1535                     'id'            => $recordGrants->getId(),
1536                     'container_id'  => $containerId,
1537                     'account_id'    => $recordGrants['account_id'],
1538                     'account_type'  => $recordGrants['account_type'],
1539                 );
1540                 if (empty($data['id'])) {
1541                     $data['id'] = $recordGrants->generateUID();
1542                 }
1543                 
1544                 foreach ($recordGrants as $grantName => $grant) {
1545                     if (in_array($grantName, $recordGrants->getAllGrants()) && $grant === TRUE) {
1546                         $this->_getContainerAclTable()->insert($data + array('account_grant' => $grantName));
1547                     }
1548                 }
1549             }
1550             
1551             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1552             
1553             $this->_setRecordMetaDataAndUpdate($containerId, 'update');
1554             
1555         } catch (Exception $e) {
1556             Tinebase_TransactionManager::getInstance()->rollBack();
1557             throw new Tinebase_Exception_Backend($e->getMessage());
1558         }
1559         
1560         return $this->getGrantsOfContainer($containerId, $_ignoreAcl);
1561     }
1562     
1563     /**
1564      * get owner (account_id) of container
1565      * 
1566      * @param Tinebase_Model_Container $_container
1567      * @return string|boolean
1568      */
1569     public function getContainerOwner(Tinebase_Model_Container $_container)
1570     {
1571         if ($_container->type !== Tinebase_Model_Container::TYPE_PERSONAL) {
1572             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1573                 . ' Only personal containers have an owner.');
1574             return FALSE;
1575         }
1576         
1577         $grants = (! $_container->account_grants) ? $this->getGrantsOfContainer($_container, true) : $_container->account_grants;
1578         
1579         if (count($grants) === 0) {
1580             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1581                 . ' Container ' . $_container->name . ' has no account grants.');
1582             return FALSE;
1583         }
1584         
1585         // return first admin user
1586         foreach ($grants as $grant) {
1587             if ($grant->{Tinebase_Model_Grants::GRANT_ADMIN} && $grant->account_type == Tinebase_Acl_Rights::ACCOUNT_TYPE_USER) {
1588                 return $grant->account_id;
1589             }
1590         }
1591         
1592         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(
1593             __METHOD__ . '::' . __LINE__ . ' Container ' . $_container->name . ' has no owner.');
1594         
1595         return FALSE;
1596     }
1597     
1598     /**
1599      * only one admin is allowed for personal containers
1600      * 
1601      * @param $_container
1602      * @throws Tinebase_Exception_Record_NotAllowed
1603      * @throws Tinebase_Exception_UnexpectedValue
1604      */
1605     public function checkContainerOwner(Tinebase_Model_Container $_container)
1606     {
1607         if ($_container->type !== Tinebase_Model_Container::TYPE_PERSONAL || empty($_container->account_grants)) {
1608             return;
1609         }
1610         
1611         if (! $_container->account_grants instanceof Tinebase_Record_RecordSet) {
1612             throw new Tinebase_Exception_UnexpectedValue('RecordSet of grants expected.');
1613         }
1614
1615         $_container->account_grants->addIndices(array(Tinebase_Model_Grants::GRANT_ADMIN));
1616         $adminGrants = $_container->account_grants->filter(Tinebase_Model_Grants::GRANT_ADMIN, TRUE);
1617         if (count($adminGrants) > 1) {
1618             Tinebase_Core::getLogger()->warn(__METHOD__ . '::' . __LINE__ . ' Multiple admin grants detected in container "' . $_container->name . '"');
1619             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' ' . print_r($adminGrants->toArray(), TRUE));
1620             throw new Tinebase_Exception_Record_NotAllowed('Personal containers can have only one owner!', 403);
1621         }
1622     }
1623     
1624     /**
1625      * remove all container related entries from cache
1626      * 
1627      * @param int|Tinebase_Model_Container $containerId
1628      */
1629     protected function _clearCache($containerId) 
1630     {
1631         $containerId = Tinebase_Model_Container::convertContainerIdToInt($containerId);
1632         $cache = Tinebase_Core::getCache();
1633         
1634         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ 
1635             . ' Removing all cache entries for container id ' . $containerId);
1636         
1637         $idsToDelete = array(
1638             'getContainerById' . $containerId . 'd0',
1639             'getContainerById' . $containerId . 'd1',
1640         );
1641         
1642         foreach ($idsToDelete as $id) {
1643             $cache->remove($id);
1644         }
1645         
1646         $this->resetClassCache();
1647     }
1648
1649     /**
1650      * lazy loading for containerACLTable
1651      * 
1652      * @return Tinebase_Db_Table
1653      */
1654     protected function _getContainerAclTable()
1655     {
1656         if (! $this->_containerAclTable) {
1657             $this->_containerAclTable = new Tinebase_Db_Table(array('name' => SQL_TABLE_PREFIX . 'container_acl'));
1658         }
1659         
1660         return $this->_containerAclTable;
1661     }
1662     
1663     /**
1664      * get grants record from an array with grant values
1665      *
1666      * @param array $_grantsArray
1667      * @param int $_accountId
1668      * @param string $_grantModel
1669      * @return Tinebase_Model_Grants (or child class)
1670      */
1671     protected function _getGrantsFromArray(array $_grantsArray, $_accountId, $_grantModel = 'Tinebase_Model_Grants')
1672     {
1673         $grants = array();
1674         foreach($_grantsArray as $key => $value) {
1675             $grantValue = (is_array($value)) ? $value['account_grant'] : $value;
1676             $grants[$grantValue] = TRUE;
1677         }
1678         $grantsFields = array(
1679             'account_id'     => $_accountId,
1680             'account_type'   => Tinebase_Acl_Rights::ACCOUNT_TYPE_USER,
1681         );
1682         $grantsFields = array_merge($grantsFields, $grants);
1683         
1684         $grants = new $_grantModel($grantsFields, TRUE);
1685
1686         return $grants;
1687     }
1688
1689     /**
1690      * increase content sequence of container
1691      * - should be increased for each create/update/delete operation in this container
1692      * 
1693      * @param integer|Tinebase_Model_Container $containerId
1694      * @param string $action
1695      * @param string $recordId
1696      * @return integer new content seq
1697      */
1698     public function increaseContentSequence($containerId, $action = NULL, $recordId = NULL)
1699     {
1700         $containerId = Tinebase_Model_Container::convertContainerIdToInt($containerId);
1701
1702         $newContentSeq = NULL;
1703         try {
1704             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($this->_db);
1705         
1706             $quotedIdentifier = $this->_db->quoteIdentifier('content_seq');
1707             $data = array(
1708                 'content_seq' => new Zend_Db_Expr('(CASE WHEN ' . $quotedIdentifier . ' >= 1 THEN ' . $quotedIdentifier . ' + 1 ELSE 1 END)')
1709             );
1710             $where = array(
1711                 $this->_db->quoteInto($this->_db->quoteIdentifier('id') . ' = ?', $containerId)
1712             );
1713             $this->_db->update($this->_tablePrefix . $this->_tableName, $data, $where);
1714             
1715             $newContentSeq = $this->getContentSequence($containerId);
1716             if ($newContentSeq === NULL) {
1717                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
1718                     . ' Something strange happend: content seq of NULL has been detected for container ' . $containerId . ' . Setting it to 0.');
1719                 $newContentSeq = 0;
1720             } else {
1721                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1722                     . ' Increased content seq of container ' . $containerId . ' to ' . $newContentSeq);
1723             }
1724             
1725             // create new entry in container_content table
1726             if ($action !== NULL && $recordId !== NULL) {
1727                 $contentRecord = new Tinebase_Model_ContainerContent(array(
1728                     'container_id' => $containerId,
1729                     'action'       => $action,
1730                     'record_id'    => $recordId,
1731                     'time'         => Tinebase_DateTime::now(),
1732                     'content_seq'  => $newContentSeq,
1733                 ));
1734                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1735                     . ' Creating "' . $action . '" action content history record for record id ' . $recordId);
1736                 $this->getContentBackend()->create($contentRecord);
1737             }
1738             
1739             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1740             
1741             $this->resetClassCache();
1742             
1743         } catch (Exception $e) {
1744             Tinebase_TransactionManager::getInstance()->rollBack();
1745             throw $e;
1746         }
1747         
1748         return $newContentSeq;
1749     }
1750     
1751     /**
1752      * get content history since given content_seq 
1753      * 
1754      * @param integer|Tinebase_Model_Container $containerId
1755      * @param integer $lastContentSeq
1756      * @return Tinebase_Record_RecordSet
1757      */
1758     public function getContentHistory($containerId, $lastContentSeq = 0)
1759     {
1760         $filter = new Tinebase_Model_ContainerContentFilter(array(
1761             array('field' => 'container_id', 'operator' => 'equals',  'value' => Tinebase_Model_Container::convertContainerIdToInt($containerId)),
1762             array('field' => 'content_seq',  'operator' => 'greater', 'value' => $lastContentSeq),
1763         ));
1764         $pagination = new Tinebase_Model_Pagination(array(
1765             'sort' => 'content_seq'
1766         ));
1767         $result = $this->getContentBackend()->search($filter, $pagination);
1768         return $result;
1769     }
1770
1771     /**
1772      * get content sequences for single container or array of ids
1773      * 
1774      * @param array|integer|Tinebase_Model_Container $containerIds
1775      * @return array with key = container id / value = content seq number | integer
1776      */
1777     public function getContentSequence($containerIds)
1778     {
1779         if (empty($containerIds)) {
1780             return NULL;
1781         }
1782         
1783         $containerIds = (! is_array($containerIds)) ? Tinebase_Model_Container::convertContainerIdToInt($containerIds) : $containerIds;
1784         
1785         $select = $this->_getSelect(array('id', 'content_seq'), TRUE);
1786         $select->where($this->_db->quoteInto($this->_db->quoteIdentifier('id') . ' IN (?)', (array) $containerIds));
1787         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1788         $result = $stmt->fetchAll();
1789         foreach ($result as $key => $value) {
1790             $result[$value['id']] = $value['content_seq'];
1791         }
1792         
1793         $result = (is_array($containerIds)) ? $result : ((isset($result[$containerIds])) ? $result[$containerIds] : NULL);
1794         return $result;
1795     }
1796     
1797     /**
1798      * checks if container to delete is a "system" container 
1799      * 
1800      * @param array|integer|Tinebase_Model_Container $containerIds
1801      * @throws Tinebase_Exception_Record_SystemContainer
1802      * 
1803      * @TODO: generalize when there are more "system" containers
1804      * @todo move Admin_Model_Config::DEFAULTINTERNALADDRESSBOOK to adb config
1805      */
1806     public function checkSystemContainer($containerIds)
1807     {
1808         if (!is_array($containerIds)) $containerIds = array($containerIds);
1809         $appConfigDefaults = Admin_Controller::getInstance()->getConfigSettings();
1810         // at the moment, just the internal addressbook is checked
1811         try {
1812             $defaultAddressbook = $this->get($appConfigDefaults[Admin_Model_Config::DEFAULTINTERNALADDRESSBOOK])->toArray();
1813         } catch (Tinebase_Exception_NotFound $e) {
1814             $defaultAddressbook = null;
1815         }
1816
1817         if ($defaultAddressbook && in_array($defaultAddressbook['id'], $containerIds)) {
1818             // _('You are not allowed to delete this Container. Please define another container as the default addressbook for internal contacts!')
1819             throw new Tinebase_Exception_Record_SystemContainer('You are not allowed to delete this Container. Please define another container as the default addressbook for internal contacts!');
1820         }
1821     }
1822     
1823     /**
1824      * create a new system container
1825      * - by default user group gets READ grant
1826      * - by default admin group gets all grants
1827      *
1828      * NOTE: this should never be called in user land and only in admin/setup contexts
1829      * 
1830      * @param Tinebase_Model_Application|string $application app record, app id or app name
1831      * @param string $name
1832      * @param string $idConfig save id in config if given
1833      * @param Tinebase_Record_RecordSet $grants use this to overwrite default grants
1834      * @param string $model the model the container contains
1835      * @return Tinebase_Model_Container
1836      */
1837     public function createSystemContainer($application, $name, $configId = NULL, Tinebase_Record_RecordSet $grants = NULL, $model = NULL)
1838     {
1839         $application = ($application instanceof Tinebase_Model_Application) ? $application : Tinebase_Application::getInstance()->getApplicationById($application);
1840         if ($model === null) {
1841             $controller = Tinebase_Core::getApplicationInstance($application->name, /* $_modelName = */ '', /* $_ignoreACL = */ true);
1842             $model = $controller->getDefaultModel();
1843         }
1844         
1845         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1846             . ' Creating system container for model ' . $model);
1847         
1848         $newContainer = new Tinebase_Model_Container(array(
1849             'name'              => $name,
1850             'type'              => Tinebase_Model_Container::TYPE_SHARED,
1851             'backend'           => 'Sql',
1852             'application_id'    => $application->getId(),
1853             'model'             => $model
1854         ));
1855         $groupsBackend = Tinebase_Group::getInstance();
1856         $grants = ($grants) ? $grants : new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(
1857             array(
1858                 'account_id'      => $groupsBackend->getDefaultGroup()->getId(),
1859                 'account_type'    => Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP,
1860                 Tinebase_Model_Grants::GRANT_READ    => true,
1861                 Tinebase_Model_Grants::GRANT_EXPORT  => true,
1862                 Tinebase_Model_Grants::GRANT_SYNC    => true,
1863             ),
1864             array(
1865                 'account_id'      => $groupsBackend->getDefaultAdminGroup()->getId(),
1866                 'account_type'    => Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP,
1867                 Tinebase_Model_Grants::GRANT_READ    => true,
1868                 Tinebase_Model_Grants::GRANT_ADD     => true,
1869                 Tinebase_Model_Grants::GRANT_EDIT    => true,
1870                 Tinebase_Model_Grants::GRANT_DELETE  => true,
1871                 Tinebase_Model_Grants::GRANT_ADMIN   => true,
1872                 Tinebase_Model_Grants::GRANT_EXPORT  => true,
1873                 Tinebase_Model_Grants::GRANT_SYNC    => true,
1874             ),
1875         ), TRUE);
1876         
1877         $newContainer = Tinebase_Container::getInstance()->addContainer($newContainer, $grants, TRUE);
1878
1879         if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1880             . ' Created new system container ' . $name . ' for application ' . $application->name);
1881         
1882         if ($configId !== NULL) {
1883             $configClass = $application->name . '_Config';
1884             if (@class_exists($configClass)) {
1885                 $config = call_user_func(array($configClass, 'getInstance'));
1886                 
1887                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1888                     . ' Setting system container config "' . $configId . '" = ' . $newContainer->getId());
1889                 
1890                 $config->set($configId, $newContainer->getId());
1891             } else {
1892                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
1893                     . ' Could not find preferences class ' . $configClass);
1894             }
1895         }
1896         
1897         $this->resetClassCache();
1898         
1899         return $newContainer;
1900     }
1901
1902     /**
1903      * Updates existing container and clears the cache entry of the container
1904      *
1905      * @param Tinebase_Record_Interface $_record
1906      * @return Tinebase_Record_Interface Record|NULL
1907      */
1908     public function update(Tinebase_Record_Interface $_record)
1909     {
1910         $this->_clearCache($_record);
1911         
1912         return parent::update($_record);
1913     }
1914 }