0011984: printing events with tags is broken for daysview
[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         // TODO maybe this could be removed or changed to a preference later
846         $sortOrder = Tinebase_Config::getInstance()->featureEnabled(Tinebase_Config::FEATURE_CONTAINER_CUSTOM_SORT)
847             ? array('container.order', 'container.name')
848             : 'container.name';
849         $select->order($sortOrder);
850
851         $this->addGrantsSql($select, $accountId, $grant, 'container_acl', $_andGrants, __CLASS__ . '::addGrantsSqlCallback');
852         
853         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
854         
855         $containers = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $stmt->fetchAll(Zend_Db::FETCH_ASSOC), TRUE);
856         
857         $this->saveInClassCache(__FUNCTION__, $classCacheId, $containers);
858         
859         Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
860             . ' Found ' . count($containers) . ' shared container(s) in application ' . $application->name);
861         
862         return $containers;
863     }
864     
865     /**
866      * return users which made personal containers accessible to given account
867      *
868      * @param   string|Tinebase_Model_User          $_accountId
869      * @param   string|Tinebase_Model_Application   $recordClass
870      * @param   array|string                        $_grant
871      * @param   bool                                $_ignoreACL
872      * @param   bool                                $_andGrants
873      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_User
874      */
875     public function getOtherUsers($_accountId, $recordClass, $_grant, $_ignoreACL = FALSE, $_andGrants = FALSE)
876     {
877         $meta = $this->_resolveRecordClassArgument($recordClass);
878         $userIds = $this->_getOtherAccountIds($_accountId, $meta['appName'], $_grant, $_ignoreACL, $_andGrants);
879         
880         $users = Tinebase_User::getInstance()->getMultiple($userIds);
881         $users->sort('accountDisplayName');
882         
883         return $users;
884     }
885
886     /**
887      * appends container_acl sql
888      *
889      * @param  Zend_Db_Select    $_select
890      * @param  integer           $iteration
891      * @return string table identifier to work on
892      */
893     public static function addGrantsSqlCallback($_select, $iteration)
894     {
895         $db = $_select->getAdapter();
896         $_select->join(array(
897             /* table  */ 'container_acl' . $iteration => SQL_TABLE_PREFIX . 'container_acl'),
898             /* on     */ $db->quoteIdentifier('container_acl' . $iteration . '.container_id') . ' = ' . $db->quoteIdentifier('container.id'),
899             array()
900         );
901         return 'container_acl' . $iteration;
902     }
903
904     /**
905      * return account ids of accounts which made personal container accessible to given account
906      *
907      * @param   string|Tinebase_Model_User          $_accountId
908      * @param   string|Tinebase_Model_Application   $_application
909      * @param   array|string                        $_grant
910      * @param   bool                                $_ignoreACL
911      * @param   bool                                $_andGrants
912      * @return  array of array of containerData
913      */
914     protected function _getOtherAccountIds($_accountId, $_application, $_grant, $_ignoreACL = FALSE, $_andGrants = FALSE)
915     {
916         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
917         $application = Tinebase_Application::getInstance()->getApplicationByName($_application);
918         $grant       = $_ignoreACL ? '*' : $_grant;
919
920         $classCacheId = Tinebase_Helper::convertCacheId($accountId . $application->getId() . implode('', (array)$grant) . (int)$_ignoreACL . (int)$_andGrants);
921         try {
922             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
923         } catch (Tinebase_Exception_NotFound $tenf) {
924             // continue...
925         }
926
927         // first grab all container ids ...
928         $select = $this->_db->select()
929             ->distinct()
930             ->from(array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'), array())
931             ->join(array(
932                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
933                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
934                 /* select */ array('container_id' => 'container.id')
935             )
936             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
937             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_PERSONAL)
938             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE);
939
940         $this->addGrantsSql($select, $accountId, $grant, 'container_acl', $_andGrants, __CLASS__ . '::addGrantsSqlCallback');
941
942         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
943         $containerIds = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
944         
945         // no container ids found / can stop here
946         if (empty($containerIds)) {
947             return $containerIds;
948         }
949         
950         // ... now get the owners of the containers 
951         $select = $this->_db->select()
952             ->distinct()
953             ->from(array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'), array('account_id'))
954             ->join(array(
955                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
956                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
957                 /* select */ array()
958             )
959             ->join(array(
960                 /* table  */ 'accounts' => SQL_TABLE_PREFIX . 'accounts'),
961                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.account_id')} = {$this->_db->quoteIdentifier('accounts.id')}",
962                 /* select */ array()
963             )
964             ->where("{$this->_db->quoteIdentifier('container.id')} IN (?)", $containerIds)
965             ->where("{$this->_db->quoteIdentifier('container_acl.account_id')} != ?", $accountId)
966             ->where("{$this->_db->quoteIdentifier('container_acl.account_grant')} = ?", Tinebase_Model_Grants::GRANT_ADMIN)
967             ->where("{$this->_db->quoteIdentifier('accounts.status')} = ?", 'enabled');
968             
969         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
970         $accountIds = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
971
972         $this->saveInClassCache(__FUNCTION__, $classCacheId, $accountIds);
973         
974         return $accountIds;
975     }
976     
977     /**
978      * return set of all personal container of other users made accessible to the given account 
979      *
980      * @param   string|Tinebase_Model_User          $_accountId
981      * @param   string|Tinebase_Model_Application   $recordClass
982      * @param   array|string                        $_grant
983      * @param   bool                                $_ignoreACL
984      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_Container
985      */
986     public function getOtherUsersContainer($_accountId, $recordClass, $_grant, $_ignoreACL = FALSE)
987     {
988         // legacy handling
989         $meta = $this->_resolveRecordClassArgument($recordClass);
990         $result = $this->_getOtherUsersContainerData($_accountId, $meta['appName'], $_grant, $_ignoreACL);
991
992         return $result;
993     }
994     
995     /**
996      * return containerData of containers which made personal accessible to given account
997      *
998      * @param   string|Tinebase_Model_User          $_accountId
999      * @param   string|Tinebase_Model_Application   $_application
1000      * @param   array|string                        $_grant
1001      * @param   bool                                $_ignoreACL
1002      * @return  Tinebase_Record_RecordSet set of Tinebase_Model_Container
1003      */
1004     protected function _getOtherUsersContainerData($_accountId, $_application, $_grant, $_ignoreACL = FALSE)
1005     {
1006         $accountId   = Tinebase_Model_User::convertUserIdToInt($_accountId);
1007         $application = Tinebase_Application::getInstance()->getApplicationByName($_application);
1008         $grant       = $_ignoreACL ? '*' : $_grant;
1009         
1010         $classCacheId = $accountId .
1011                         $application->getId() .
1012                         implode('', (array)$grant) .
1013                         (int)$_ignoreACL;
1014         
1015         try {
1016             return $this->loadFromClassCache(__FUNCTION__, $classCacheId);
1017         } catch (Tinebase_Exception_NotFound $tenf) {
1018             // continue...
1019         }
1020         
1021         $select = $this->_db->select()
1022             ->from(array('owner' => SQL_TABLE_PREFIX . 'container_acl'), array('account_id'))
1023             ->join(array(
1024                 /* table  */ 'user' => SQL_TABLE_PREFIX . 'container_acl'), 
1025                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('user.container_id')}",
1026                 /* select */ array()
1027             )
1028             ->join(array(
1029                 /* table  */ 'container' => SQL_TABLE_PREFIX . 'container'), 
1030                 /* on     */ "{$this->_db->quoteIdentifier('owner.container_id')} = {$this->_db->quoteIdentifier('container.id')}"
1031             )
1032             ->join(array(
1033                 /* table  */ 'accounts' => SQL_TABLE_PREFIX . 'accounts'),
1034                 /* on     */ "{$this->_db->quoteIdentifier('owner.account_id')} = {$this->_db->quoteIdentifier('accounts.id')}",
1035                 /* select */ array()
1036             )
1037             #->join(array(
1038             #    /* table  */ 'contacts' => SQL_TABLE_PREFIX . 'addressbook'),
1039             #    /* on     */ "{$this->_db->quoteIdentifier('owner.account_id')} = {$this->_db->quoteIdentifier('contacts.account_id')}",
1040             #    /* select */ array()
1041             #)
1042             ->where("{$this->_db->quoteIdentifier('owner.account_id')} != ?", $accountId)
1043             ->where("{$this->_db->quoteIdentifier('owner.account_grant')} = ?", Tinebase_Model_Grants::GRANT_ADMIN)
1044             
1045             ->where("{$this->_db->quoteIdentifier('container.application_id')} = ?", $application->getId())
1046             ->where("{$this->_db->quoteIdentifier('container.type')} = ?", Tinebase_Model_Container::TYPE_PERSONAL)
1047             ->where("{$this->_db->quoteIdentifier('container.is_deleted')} = ?", 0, Zend_Db::INT_TYPE)
1048             ->where("{$this->_db->quoteIdentifier('accounts.status')} = ?", 'enabled')
1049             
1050             ->order('accounts.display_name')
1051             ->group('owner.account_id');
1052         
1053         $this->addGrantsSql($select, $accountId, $grant, 'user');
1054         
1055         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1056         
1057         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1058         
1059         $containers = new Tinebase_Record_RecordSet('Tinebase_Model_Container', $stmt->fetchAll(Zend_Db::FETCH_ASSOC), TRUE);
1060
1061         $this->saveInClassCache(__FUNCTION__, $classCacheId, $containers);
1062         
1063         return $containers;
1064     }
1065     
1066     /**
1067      * delete container if user has the required right
1068      *
1069      * @param   int|Tinebase_Model_Container $_containerId
1070      * @param   boolean $_ignoreAcl
1071      * @param   boolean $_tryAgain
1072      * @throws  Tinebase_Exception_AccessDenied
1073      * @throws  Tinebase_Exception_Record_SystemContainer
1074      * @throws  Tinebase_Exception_InvalidArgument
1075      * 
1076      * @todo move records in deleted container to personal container?
1077      */
1078     public function deleteContainer($_containerId, $_ignoreAcl = FALSE, $_tryAgain = TRUE)
1079     {
1080         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1081         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($containerId);
1082         $this->checkSystemContainer($containerId);
1083         
1084         $tm = Tinebase_TransactionManager::getInstance();   
1085         $myTransactionId = $tm->startTransaction(Tinebase_Core::getDb());
1086
1087         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1088             . ' Deleting container id ' . $containerId . ' ...');
1089
1090         $deletedContainer = NULL;
1091         
1092         try {
1093             if($_ignoreAcl !== TRUE) {
1094                 if(!$this->hasGrant(Tinebase_Core::getUser(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1095                     throw new Tinebase_Exception_AccessDenied('Permission to delete container denied.');
1096                 }
1097                 
1098                 if($container->type !== Tinebase_Model_Container::TYPE_PERSONAL and $container->type !== Tinebase_Model_Container::TYPE_SHARED) {
1099                     throw new Tinebase_Exception_InvalidArgument('Can delete personal or shared containers only.');
1100                 }
1101             }
1102             $this->deleteContainerContents($container, $_ignoreAcl);
1103             $deletedContainer = $this->_setRecordMetaDataAndUpdate($container, 'delete');
1104             
1105         } catch (Exception $e) {
1106             $tm->rollBack();
1107             throw $e;
1108         }
1109         
1110         $tm->commitTransaction($myTransactionId);
1111         
1112         return $deletedContainer;
1113
1114         /*
1115         // move all contained objects to next available personal container and try again to delete container
1116         $app = Tinebase_Application::getApplicationById($container->application_id);
1117
1118         // get personal containers
1119         $personalContainers = $this->getPersonalContainer(
1120             Tinebase_Core::getUser(),
1121             $app->name,
1122             $container->owner,
1123             Tinebase_Model_Grants::GRANT_ADD
1124         );
1125         
1126         //-- determine first matching personal container (or create new one)
1127         // $personalContainer =
1128         
1129         //-- move all records to personal container
1130         
1131         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1132             . ' Moving all records from container ' . $containerId . ' to personal container ' . $personalContainer->getId()
1133         );
1134         */
1135     }
1136     
1137     /**
1138      * set delete flag of records belonging to the given container
1139      * 
1140      * @param Tinebase_Model_Container $container
1141      */
1142     public function deleteContainerContents($container, $_ignoreAcl = FALSE)
1143     {
1144         $model = $container->model;
1145
1146         if (empty($model)) {
1147             Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1148                 . ' No container model defined');
1149             return;
1150         }
1151
1152         $controller = Tinebase_Core::getApplicationInstance($model);
1153         $filterName = $model . 'Filter';
1154
1155         if ($_ignoreAcl === TRUE && method_exists($controller, 'doContainerACLChecks')) {
1156             $acl = $controller->doContainerACLChecks(FALSE);
1157         }
1158         if ($controller && class_exists($filterName)) {
1159             Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1160                 . ' Delete ' . $model . ' records in container ' . $container->getId());
1161
1162             $filter = new $filterName(array(array(
1163                 'field'    => 'container_id',
1164                 'operator' => 'equals',
1165                 'value'    => intval($container->id)
1166             )), Tinebase_Model_Filter_FilterGroup::CONDITION_AND, array('ignoreAcl' => $_ignoreAcl));
1167
1168             if ($_ignoreAcl) {
1169                 $backend = $controller::getInstance()->getBackend();
1170                 $idsToDelete = $backend->search($filter, null, /* $_onlyIds */ true);
1171                 $controller::getInstance()->delete($idsToDelete);
1172             } else {
1173                 $controller::getInstance()->deleteByFilter($filter);
1174             }
1175         }
1176
1177         if ($_ignoreAcl === TRUE && method_exists($controller, 'doContainerACLChecks')) {
1178             $controller->doContainerACLChecks($acl);
1179         }
1180     }
1181     
1182     /**
1183      * delete container by application id
1184      * 
1185      * @param string $_applicationId
1186      * @return integer numer of deleted containers 
1187      */
1188     public function deleteContainerByApplicationId($_applicationId)
1189     {
1190         $this->resetClassCache();
1191         
1192         return $this->deleteByProperty($_applicationId, 'application_id');
1193     }
1194     
1195     /**
1196      * set container name, if the user has the required right
1197      *
1198      * @param   int|Tinebase_Model_Container $_containerId
1199      * @param   string $_containerName the new name
1200      * @return  Tinebase_Model_Container
1201      * @throws  Tinebase_Exception_AccessDenied
1202      */
1203     public function setContainerName($_containerId, $_containerName)
1204     {
1205         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1206         
1207         if (!$this->hasGrant(Tinebase_Core::getUser(), $container, Tinebase_Model_Grants::GRANT_ADMIN)) {
1208             throw new Tinebase_Exception_AccessDenied('Permission to rename container denied.');
1209         }
1210         
1211         $container->name = $_containerName;
1212         
1213         return $this->_setRecordMetaDataAndUpdate($container, 'update');
1214     }
1215     
1216     /**
1217      * set container color, if the user has the required right
1218      *
1219      * @param   int|Tinebase_Model_Container $_containerId
1220      * @param   string $_color the new color
1221      * @return  Tinebase_Model_Container
1222      * @throws  Tinebase_Exception_AccessDenied
1223      */
1224     public function setContainerColor($_containerId, $_color)
1225     {
1226         $container = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1227
1228         if (! $this->hasGrant(Tinebase_Core::getUser(), $container, Tinebase_Model_Grants::GRANT_ADMIN)) {
1229             throw new Tinebase_Exception_AccessDenied('Permission to set color of container denied.');
1230         }
1231         
1232         if (! preg_match('/^#[0-9a-fA-F]{6}$/', $_color)) {
1233             throw new Tinebase_Exception_UnexpectedValue('color is not valid');
1234         }
1235         
1236         $container->color = $_color;
1237         
1238         return $this->_setRecordMetaDataAndUpdate($container, 'update');
1239     }
1240     
1241     /**
1242      * check if the given user user has a certain grant
1243      *
1244      * @param   string|Tinebase_Model_User          $_accountId
1245      * @param   int|Tinebase_Model_Container        $_containerId
1246      * @param   array|string                        $_grant
1247      * @return  boolean
1248      */
1249     public function hasGrant($_accountId, $_containerId, $_grant)
1250     {
1251         $accountId = Tinebase_Model_User::convertUserIdToInt($_accountId);
1252         
1253         try {
1254             $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1255         } catch (Tinebase_Exception_InvalidArgument $teia) {
1256             if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__ . ' ' . $teia->getMessage());
1257             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' ' . $teia->getTraceAsString());
1258             return false;
1259         }
1260         
1261         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1262             . ' account: ' . $accountId . ' / containerId: ' . $containerId . ' / grant:' . implode('/', (array)$_grant));
1263         
1264         $classCacheId = $accountId . $containerId . implode('', (array)$_grant);
1265         
1266         try {
1267             $allGrants = $this->loadFromClassCache(__FUNCTION__, $classCacheId);
1268         } catch (Tinebase_Exception_NotFound $tenf) {
1269             // NOTE: some tests ask for already deleted container ;-)
1270             $select = $this->_getSelect(array(), true)
1271                 ->distinct()
1272                 ->where("{$this->_db->quoteIdentifier('container.id')} = ?", $containerId)
1273                 ->join(array(
1274                     /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
1275                     /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
1276                     /* select */ array('container_acl.account_grant')
1277                 );
1278                 
1279             $this->addGrantsSql($select, $accountId, '*');
1280             
1281             $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1282             
1283             $allGrants = $stmt->fetchAll(Zend_Db::FETCH_COLUMN);
1284             $this->saveInClassCache(__FUNCTION__, $classCacheId, $allGrants);
1285         }
1286         
1287         $matchingGrants = array_intersect((array)$_grant, $allGrants);
1288         
1289         return !!count($matchingGrants);
1290     }
1291     
1292     /**
1293      * get all grants assigned to this container
1294      *
1295      * @param   int|Tinebase_Model_Container $_containerId
1296      * @param   bool                         $_ignoreAcl
1297      * @param   string                       $_grantModel
1298      * @return  Tinebase_Record_RecordSet subtype Tinebase_Model_Grants
1299      * @throws  Tinebase_Exception_AccessDenied
1300      */
1301     public function getGrantsOfContainer($_containerId, $_ignoreAcl = FALSE, $_grantModel = 'Tinebase_Model_Grants') 
1302     {
1303         $grants = new Tinebase_Record_RecordSet('Tinebase_Model_Grants');
1304         
1305         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1306         
1307         $select = $this->_getAclSelectByContainerId($containerId)
1308             ->group(array('container_acl.container_id', 'container_acl.account_type', 'container_acl.account_id'));
1309         
1310         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1311         
1312         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1313
1314         $grantsData = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1315         
1316         foreach($grantsData as $grantData) {
1317             $givenGrants = explode(',', $grantData['account_grants']);
1318             foreach($givenGrants as $grant) {
1319                 $grantData[$grant] = TRUE;
1320             }
1321             
1322             $containerGrant = new $_grantModel($grantData, TRUE);
1323
1324             $grants->addRecord($containerGrant);
1325         }
1326         
1327         if ($_ignoreAcl !== TRUE) {
1328             if (TRUE !== $this->hasGrant(Tinebase_Core::getUser()->getId(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1329                 throw new Tinebase_Exception_AccessDenied('Permission to get grants of container denied.');
1330             }
1331         }
1332         return $grants;
1333     }
1334     
1335     /**
1336      * get select with acl (grants) by container ID
1337      * 
1338      * @param integer $containerId
1339      * @return Zend_Db_Select
1340      */
1341     protected function _getAclSelectByContainerId($containerId)
1342     {
1343          $select = $this->_db->select()
1344             ->from(
1345                 array('container_acl' => SQL_TABLE_PREFIX . 'container_acl'),
1346                 array('*', 'account_grants' => $this->_dbCommand->getAggregate('container_acl.account_grant'))
1347             )
1348             ->where("{$this->_db->quoteIdentifier('container_acl.container_id')} = ?", $containerId);
1349          return $select;
1350     }
1351     
1352     /**
1353      * get grants assigned to one account of one container
1354      *
1355      * @param   string|Tinebase_Model_User          $_accountId
1356      * @param   int|Tinebase_Model_Container        $_containerId
1357      * @param   string                              $_grantModel
1358      * @return Tinebase_Model_Grants
1359      */
1360     public function getGrantsOfAccount($_accountId, $_containerId, $_grantModel = 'Tinebase_Model_Grants') 
1361     {
1362         $accountId          = Tinebase_Model_User::convertUserIdToInt($_accountId);
1363         $containerId        = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1364         $container          = ($_containerId instanceof Tinebase_Model_Container) ? $_containerId : $this->getContainerById($_containerId);
1365         
1366         $classCacheId = $accountId . $containerId . $container->seq . $_grantModel;
1367         
1368         try {
1369             $grants = $this->loadFromClassCache(__FUNCTION__, $classCacheId, Tinebase_Cache_PerRequest::VISIBILITY_SHARED);
1370             if ($grants instanceof Tinebase_Model_Grants) {
1371                 return $grants;
1372             } else {
1373                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__ .
1374                     ' Invalid data in cache ... fetching fresh data from DB');
1375             }
1376         } catch (Tinebase_Exception_NotFound $tenf) {
1377             // not found in cache
1378         }
1379         
1380         $select = $this->_getAclSelectByContainerId($containerId)
1381             ->group('container_acl.account_grant');
1382         
1383         $this->addGrantsSql($select, $accountId, '*');
1384         
1385         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1386         
1387         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1388         
1389         $rows = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1390         
1391         $grants = $this->_getGrantsFromArray($rows, $accountId, $_grantModel);
1392         
1393         $this->saveInClassCache(__FUNCTION__, $classCacheId, $grants, Tinebase_Cache_PerRequest::VISIBILITY_SHARED, self::ACL_CACHE_TIMEOUT);
1394         
1395         return $grants;
1396     }
1397     
1398     /**
1399      * get grants assigned to given account of multiple records
1400      *
1401      * @param   Tinebase_Record_RecordSet   $_records records to get the grants for
1402      * @param   string|Tinebase_Model_User  $_accountId the account to get the grants for
1403      * @param   string                      $_containerProperty container property
1404      * @param   string                      $_grantModel
1405      * @throws  Tinebase_Exception_NotFound
1406      */
1407     public function getGrantsOfRecords(Tinebase_Record_RecordSet $_records, $_accountId, $_containerProperty = 'container_id', $_grantModel = 'Tinebase_Model_Grants')
1408     {
1409         $containers = $this->getContainerGrantsOfRecords($_records, $_accountId, $_containerProperty, $_grantModel);
1410         
1411         if (!$containers) {
1412             return;
1413         }
1414         
1415         // add container & grants to records
1416         foreach ($_records as &$record) {
1417             if (!$containerId = $record->$_containerProperty) {
1418                 continue;
1419             }
1420             
1421             if (! is_array($containerId) && ! $containerId instanceof Tinebase_Record_Abstract && isset($containers[$containerId])) {
1422                 if (isset($containers[$containerId]->path)) {
1423                     $record->$_containerProperty = $containers[$containerId];
1424                 } else {
1425                     // if path is not determinable, skip this container
1426                     // @todo is it correct to remove record from recordSet???
1427                     $_records->removeRecord($record);
1428                 }
1429             }
1430         }
1431     }
1432     
1433     /**
1434      * get grants for containers assigned to given account of multiple records
1435      *
1436      * @param   Tinebase_Record_RecordSet   $_records records to get the grants for
1437      * @param   string|Tinebase_Model_User  $_accountId the account to get the grants for
1438      * @param   string                      $_containerProperty container property
1439      * @param   string                      $_grantModel
1440      * @throws  Tinebase_Exception_NotFound
1441      * @return  array of containers|void
1442      */
1443     public function getContainerGrantsOfRecords(Tinebase_Record_RecordSet $_records, $_accountId, $_containerProperty = 'container_id', $_grantModel = 'Tinebase_Model_Grants')
1444     {
1445         $containerIds = array();
1446         foreach ($_records as $record) {
1447             if (isset($record[$_containerProperty]) && !isset($containerIds[Tinebase_Model_Container::convertContainerIdToInt($record[$_containerProperty])])) {
1448                 $containerIds[Tinebase_Model_Container::convertContainerIdToInt($record[$_containerProperty])] = null;
1449             }
1450         }
1451         
1452         if (empty($containerIds)) {
1453             return array();
1454         }
1455         
1456         $accountId = $_accountId instanceof Tinebase_Record_Abstract
1457             ? $_accountId->getId()
1458             : $_accountId;
1459         
1460         $select = $this->_getSelect('*', TRUE)
1461             ->where("{$this->_db->quoteIdentifier('container.id')} IN (?)", array_keys($containerIds))
1462             ->join(array(
1463                 /* table  */ 'container_acl' => SQL_TABLE_PREFIX . 'container_acl'), 
1464                 /* on     */ "{$this->_db->quoteIdentifier('container_acl.container_id')} = {$this->_db->quoteIdentifier('container.id')}",
1465                 /* select */ array('*', 'account_grants' => $this->_dbCommand->getAggregate('container_acl.account_grant'))
1466             )
1467             ->group('container.id', 'container_acl.account_type', 'container_acl.account_id');
1468             
1469         $this->addGrantsSql($select, $accountId, '*');
1470         
1471         Tinebase_Backend_Sql_Abstract::traitGroup($select);
1472         
1473         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1474         $rows = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
1475         
1476         $containers = array();
1477         // add results to container ids and get grants array
1478         foreach ($rows as $row) {
1479             // NOTE id is non-ambiguous
1480             $row['id']   = $row['container_id'];
1481             
1482             $grantsArray = array_unique(explode(',', $row['account_grants']));
1483             $row['account_grants'] = $this->_getGrantsFromArray($grantsArray, $accountId, $_grantModel)->toArray();
1484             
1485             $containers[$row['id']] = new Tinebase_Model_Container($row, TRUE);
1486             
1487             try {
1488                 $containers[$row['id']]->path = $containers[$row['id']]->getPath();
1489             } catch (Exception $e) {
1490                 // @todo is it correct to catch all exceptions here?
1491                 Tinebase_Exception::log($e);
1492             }
1493         }
1494         
1495         return $containers;
1496     }
1497     
1498     /**
1499      * set all grants for given container
1500      *
1501      * @param   int|Tinebase_Model_Container $_containerId
1502      * @param   Tinebase_Record_RecordSet $_grants
1503      * @param   boolean $_ignoreAcl
1504      * @param   boolean $_failSafe don't allow to remove all admin grants for container
1505      * @return  Tinebase_Record_RecordSet subtype Tinebase_Model_Grants
1506      * @throws  Tinebase_Exception_AccessDenied
1507      * @throws  Tinebase_Exception_Backend
1508      * @throws  Tinebase_Exception_Record_NotAllowed
1509      */
1510     public function setGrants($_containerId, Tinebase_Record_RecordSet $_grants, $_ignoreAcl = FALSE, $_failSafe = TRUE) 
1511     {
1512         $containerId = Tinebase_Model_Container::convertContainerIdToInt($_containerId);
1513         
1514         if($_ignoreAcl !== TRUE) {
1515             if(!$this->hasGrant(Tinebase_Core::getUser(), $containerId, Tinebase_Model_Grants::GRANT_ADMIN)) {
1516                 throw new Tinebase_Exception_AccessDenied('Permission to set grants of container denied.');
1517             }
1518         }
1519         
1520         // do failsafe check
1521         if ($_failSafe) {
1522             $adminGrant = FALSE;
1523             foreach ($_grants as $recordGrants) {
1524                 if ($recordGrants->{Tinebase_Model_Grants::GRANT_ADMIN}) {
1525                     $adminGrant = TRUE;
1526                 }
1527             }
1528             if (count($_grants) == 0 || ! $adminGrant) {
1529                 throw new Tinebase_Exception_UnexpectedValue('You are not allowed to remove all (admin) grants for this container.');
1530             }
1531         }
1532         
1533         if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__ . ' Setting grants for container id ' . $containerId . ' ...');
1534         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ . ' ' . print_r($_grants->toArray(), TRUE));
1535         
1536         try {
1537
1538             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction(Tinebase_Core::getDb());
1539             
1540             $where = $this->_getContainerAclTable()->getAdapter()->quoteInto($this->_db->quoteIdentifier('container_id') . ' = ?', $containerId);
1541             $this->_getContainerAclTable()->delete($where);
1542             
1543             foreach ($_grants as $recordGrants) {
1544                 $data = array(
1545                     'id'            => $recordGrants->getId(),
1546                     'container_id'  => $containerId,
1547                     'account_id'    => $recordGrants['account_id'],
1548                     'account_type'  => $recordGrants['account_type'],
1549                 );
1550                 if (empty($data['id'])) {
1551                     $data['id'] = $recordGrants->generateUID();
1552                 }
1553                 
1554                 foreach ($recordGrants as $grantName => $grant) {
1555                     if (in_array($grantName, $recordGrants->getAllGrants()) && $grant === TRUE) {
1556                         $this->_getContainerAclTable()->insert($data + array('account_grant' => $grantName));
1557                     }
1558                 }
1559             }
1560             
1561             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1562             
1563             $this->_setRecordMetaDataAndUpdate($containerId, 'update');
1564             
1565         } catch (Exception $e) {
1566             Tinebase_TransactionManager::getInstance()->rollBack();
1567             throw new Tinebase_Exception_Backend($e->getMessage());
1568         }
1569         
1570         return $this->getGrantsOfContainer($containerId, $_ignoreAcl);
1571     }
1572     
1573     /**
1574      * get owner (account_id) of container
1575      * 
1576      * @param Tinebase_Model_Container $_container
1577      * @return string|boolean
1578      */
1579     public function getContainerOwner(Tinebase_Model_Container $_container)
1580     {
1581         if ($_container->type !== Tinebase_Model_Container::TYPE_PERSONAL) {
1582             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1583                 . ' Only personal containers have an owner.');
1584             return FALSE;
1585         }
1586         
1587         $grants = (! $_container->account_grants) ? $this->getGrantsOfContainer($_container, true) : $_container->account_grants;
1588         
1589         if (count($grants) === 0) {
1590             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1591                 . ' Container ' . $_container->name . ' has no account grants.');
1592             return FALSE;
1593         }
1594         
1595         // return first admin user
1596         foreach ($grants as $grant) {
1597             if ($grant->{Tinebase_Model_Grants::GRANT_ADMIN} && $grant->account_type == Tinebase_Acl_Rights::ACCOUNT_TYPE_USER) {
1598                 return $grant->account_id;
1599             }
1600         }
1601         
1602         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(
1603             __METHOD__ . '::' . __LINE__ . ' Container ' . $_container->name . ' has no owner.');
1604         
1605         return FALSE;
1606     }
1607     
1608     /**
1609      * only one admin is allowed for personal containers
1610      * 
1611      * @param $_container
1612      * @throws Tinebase_Exception_Record_NotAllowed
1613      * @throws Tinebase_Exception_UnexpectedValue
1614      */
1615     public function checkContainerOwner(Tinebase_Model_Container $_container)
1616     {
1617         if ($_container->type !== Tinebase_Model_Container::TYPE_PERSONAL || empty($_container->account_grants)) {
1618             return;
1619         }
1620         
1621         if (! $_container->account_grants instanceof Tinebase_Record_RecordSet) {
1622             throw new Tinebase_Exception_UnexpectedValue('RecordSet of grants expected.');
1623         }
1624
1625         $_container->account_grants->addIndices(array(Tinebase_Model_Grants::GRANT_ADMIN));
1626         $adminGrants = $_container->account_grants->filter(Tinebase_Model_Grants::GRANT_ADMIN, TRUE);
1627         if (count($adminGrants) > 1) {
1628             Tinebase_Core::getLogger()->warn(__METHOD__ . '::' . __LINE__ . ' Multiple admin grants detected in container "' . $_container->name . '"');
1629             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' ' . print_r($adminGrants->toArray(), TRUE));
1630             throw new Tinebase_Exception_Record_NotAllowed('Personal containers can have only one owner!', 403);
1631         }
1632     }
1633     
1634     /**
1635      * remove all container related entries from cache
1636      * 
1637      * @param int|Tinebase_Model_Container $containerId
1638      */
1639     protected function _clearCache($containerId) 
1640     {
1641         $containerId = Tinebase_Model_Container::convertContainerIdToInt($containerId);
1642         $cache = Tinebase_Core::getCache();
1643         
1644         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ 
1645             . ' Removing all cache entries for container id ' . $containerId);
1646         
1647         $idsToDelete = array(
1648             'getContainerById' . $containerId . 'd0',
1649             'getContainerById' . $containerId . 'd1',
1650         );
1651         
1652         foreach ($idsToDelete as $id) {
1653             $cache->remove($id);
1654         }
1655         
1656         $this->resetClassCache();
1657     }
1658
1659     /**
1660      * lazy loading for containerACLTable
1661      * 
1662      * @return Tinebase_Db_Table
1663      */
1664     protected function _getContainerAclTable()
1665     {
1666         if (! $this->_containerAclTable) {
1667             $this->_containerAclTable = new Tinebase_Db_Table(array('name' => SQL_TABLE_PREFIX . 'container_acl'));
1668         }
1669         
1670         return $this->_containerAclTable;
1671     }
1672     
1673     /**
1674      * get grants record from an array with grant values
1675      *
1676      * @param array $_grantsArray
1677      * @param int $_accountId
1678      * @param string $_grantModel
1679      * @return Tinebase_Model_Grants (or child class)
1680      */
1681     protected function _getGrantsFromArray(array $_grantsArray, $_accountId, $_grantModel = 'Tinebase_Model_Grants')
1682     {
1683         $grants = array();
1684         foreach($_grantsArray as $key => $value) {
1685             $grantValue = (is_array($value)) ? $value['account_grant'] : $value;
1686             $grants[$grantValue] = TRUE;
1687         }
1688         $grantsFields = array(
1689             'account_id'     => $_accountId,
1690             'account_type'   => Tinebase_Acl_Rights::ACCOUNT_TYPE_USER,
1691         );
1692         $grantsFields = array_merge($grantsFields, $grants);
1693         
1694         $grants = new $_grantModel($grantsFields, TRUE);
1695
1696         return $grants;
1697     }
1698
1699     /**
1700      * increase content sequence of container
1701      * - should be increased for each create/update/delete operation in this container
1702      * 
1703      * @param integer|Tinebase_Model_Container $containerId
1704      * @param string $action
1705      * @param string $recordId
1706      * @return integer new content seq
1707      */
1708     public function increaseContentSequence($containerId, $action = NULL, $recordId = NULL)
1709     {
1710         $containerId = Tinebase_Model_Container::convertContainerIdToInt($containerId);
1711
1712         $newContentSeq = NULL;
1713         try {
1714             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($this->_db);
1715         
1716             $quotedIdentifier = $this->_db->quoteIdentifier('content_seq');
1717             $data = array(
1718                 'content_seq' => new Zend_Db_Expr('(CASE WHEN ' . $quotedIdentifier . ' >= 1 THEN ' . $quotedIdentifier . ' + 1 ELSE 1 END)')
1719             );
1720             $where = array(
1721                 $this->_db->quoteInto($this->_db->quoteIdentifier('id') . ' = ?', $containerId)
1722             );
1723             $this->_db->update($this->_tablePrefix . $this->_tableName, $data, $where);
1724             
1725             $newContentSeq = $this->getContentSequence($containerId);
1726             if ($newContentSeq === NULL) {
1727                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
1728                     . ' Something strange happend: content seq of NULL has been detected for container ' . $containerId . ' . Setting it to 0.');
1729                 $newContentSeq = 0;
1730             } else {
1731                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1732                     . ' Increased content seq of container ' . $containerId . ' to ' . $newContentSeq);
1733             }
1734             
1735             // create new entry in container_content table
1736             if ($action !== NULL && $recordId !== NULL) {
1737                 $contentRecord = new Tinebase_Model_ContainerContent(array(
1738                     'container_id' => $containerId,
1739                     'action'       => $action,
1740                     'record_id'    => $recordId,
1741                     'time'         => Tinebase_DateTime::now(),
1742                     'content_seq'  => $newContentSeq,
1743                 ));
1744                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1745                     . ' Creating "' . $action . '" action content history record for record id ' . $recordId);
1746                 $this->getContentBackend()->create($contentRecord);
1747             }
1748             
1749             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1750             
1751             $this->resetClassCache();
1752             
1753         } catch (Exception $e) {
1754             Tinebase_TransactionManager::getInstance()->rollBack();
1755             throw $e;
1756         }
1757         
1758         return $newContentSeq;
1759     }
1760     
1761     /**
1762      * get content history since given content_seq 
1763      * 
1764      * @param integer|Tinebase_Model_Container $containerId
1765      * @param integer $lastContentSeq
1766      * @return Tinebase_Record_RecordSet
1767      */
1768     public function getContentHistory($containerId, $lastContentSeq = 0)
1769     {
1770         $filter = new Tinebase_Model_ContainerContentFilter(array(
1771             array('field' => 'container_id', 'operator' => 'equals',  'value' => Tinebase_Model_Container::convertContainerIdToInt($containerId)),
1772             array('field' => 'content_seq',  'operator' => 'greater', 'value' => $lastContentSeq),
1773         ));
1774         $pagination = new Tinebase_Model_Pagination(array(
1775             'sort' => 'content_seq'
1776         ));
1777         $result = $this->getContentBackend()->search($filter, $pagination);
1778         return $result;
1779     }
1780
1781     /**
1782      * get content sequences for single container or array of ids
1783      * 
1784      * @param array|integer|Tinebase_Model_Container $containerIds
1785      * @return array with key = container id / value = content seq number | integer
1786      */
1787     public function getContentSequence($containerIds)
1788     {
1789         if (empty($containerIds)) {
1790             return NULL;
1791         }
1792         
1793         $containerIds = (! is_array($containerIds)) ? Tinebase_Model_Container::convertContainerIdToInt($containerIds) : $containerIds;
1794         
1795         $select = $this->_getSelect(array('id', 'content_seq'), TRUE);
1796         $select->where($this->_db->quoteInto($this->_db->quoteIdentifier('id') . ' IN (?)', (array) $containerIds));
1797         $stmt = $this->_db->query('/*' . __FUNCTION__ . '*/' . $select);
1798         $result = $stmt->fetchAll();
1799         foreach ($result as $key => $value) {
1800             $result[$value['id']] = $value['content_seq'];
1801         }
1802         
1803         $result = (is_array($containerIds)) ? $result : ((isset($result[$containerIds])) ? $result[$containerIds] : NULL);
1804         return $result;
1805     }
1806     
1807     /**
1808      * checks if container to delete is a "system" container 
1809      * 
1810      * @param array|integer|Tinebase_Model_Container $containerIds
1811      * @throws Tinebase_Exception_Record_SystemContainer
1812      * 
1813      * @TODO: generalize when there are more "system" containers
1814      * @todo move Admin_Model_Config::DEFAULTINTERNALADDRESSBOOK to adb config
1815      */
1816     public function checkSystemContainer($containerIds)
1817     {
1818         if (!is_array($containerIds)) $containerIds = array($containerIds);
1819         $appConfigDefaults = Admin_Controller::getInstance()->getConfigSettings();
1820         // at the moment, just the internal addressbook is checked
1821         try {
1822             $defaultAddressbook = $this->get($appConfigDefaults[Admin_Model_Config::DEFAULTINTERNALADDRESSBOOK])->toArray();
1823         } catch (Tinebase_Exception_NotFound $e) {
1824             $defaultAddressbook = null;
1825         }
1826
1827         if ($defaultAddressbook && in_array($defaultAddressbook['id'], $containerIds)) {
1828             // _('You are not allowed to delete this Container. Please define another container as the default addressbook for internal contacts!')
1829             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!');
1830         }
1831     }
1832     
1833     /**
1834      * create a new system container
1835      * - by default user group gets READ grant
1836      * - by default admin group gets all grants
1837      *
1838      * NOTE: this should never be called in user land and only in admin/setup contexts
1839      * 
1840      * @param Tinebase_Model_Application|string $application app record, app id or app name
1841      * @param string $name
1842      * @param string $idConfig save id in config if given
1843      * @param Tinebase_Record_RecordSet $grants use this to overwrite default grants
1844      * @param string $model the model the container contains
1845      * @return Tinebase_Model_Container
1846      */
1847     public function createSystemContainer($application, $name, $configId = NULL, Tinebase_Record_RecordSet $grants = NULL, $model = NULL)
1848     {
1849         $application = ($application instanceof Tinebase_Model_Application) ? $application : Tinebase_Application::getInstance()->getApplicationById($application);
1850         if ($model === null) {
1851             $controller = Tinebase_Core::getApplicationInstance($application->name, /* $_modelName = */ '', /* $_ignoreACL = */ true);
1852             $model = $controller->getDefaultModel();
1853         }
1854         
1855         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ 
1856             . ' Creating system container for model ' . $model);
1857         
1858         $newContainer = new Tinebase_Model_Container(array(
1859             'name'              => $name,
1860             'type'              => Tinebase_Model_Container::TYPE_SHARED,
1861             'backend'           => 'Sql',
1862             'application_id'    => $application->getId(),
1863             'model'             => $model
1864         ));
1865         $groupsBackend = Tinebase_Group::getInstance();
1866         $grants = ($grants) ? $grants : new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(
1867             array(
1868                 'account_id'      => $groupsBackend->getDefaultGroup()->getId(),
1869                 'account_type'    => Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP,
1870                 Tinebase_Model_Grants::GRANT_READ    => true,
1871                 Tinebase_Model_Grants::GRANT_EXPORT  => true,
1872                 Tinebase_Model_Grants::GRANT_SYNC    => true,
1873             ),
1874             array(
1875                 'account_id'      => $groupsBackend->getDefaultAdminGroup()->getId(),
1876                 'account_type'    => Tinebase_Acl_Rights::ACCOUNT_TYPE_GROUP,
1877                 Tinebase_Model_Grants::GRANT_READ    => true,
1878                 Tinebase_Model_Grants::GRANT_ADD     => true,
1879                 Tinebase_Model_Grants::GRANT_EDIT    => true,
1880                 Tinebase_Model_Grants::GRANT_DELETE  => true,
1881                 Tinebase_Model_Grants::GRANT_ADMIN   => true,
1882                 Tinebase_Model_Grants::GRANT_EXPORT  => true,
1883                 Tinebase_Model_Grants::GRANT_SYNC    => true,
1884             ),
1885         ), TRUE);
1886         
1887         $newContainer = Tinebase_Container::getInstance()->addContainer($newContainer, $grants, TRUE);
1888
1889         if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
1890             . ' Created new system container ' . $name . ' for application ' . $application->name);
1891         
1892         if ($configId !== NULL) {
1893             $configClass = $application->name . '_Config';
1894             if (@class_exists($configClass)) {
1895                 $config = call_user_func(array($configClass, 'getInstance'));
1896                 
1897                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1898                     . ' Setting system container config "' . $configId . '" = ' . $newContainer->getId());
1899                 
1900                 $config->set($configId, $newContainer->getId());
1901             } else {
1902                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
1903                     . ' Could not find preferences class ' . $configClass);
1904             }
1905         }
1906         
1907         $this->resetClassCache();
1908         
1909         return $newContainer;
1910     }
1911
1912     /**
1913      * Updates existing container and clears the cache entry of the container
1914      *
1915      * @param Tinebase_Record_Interface $_record
1916      * @return Tinebase_Record_Interface Record|NULL
1917      */
1918     public function update(Tinebase_Record_Interface $_record)
1919     {
1920         $this->_clearCache($_record);
1921         
1922         return parent::update($_record);
1923     }
1924 }