0004934: Ical subscription support: new container
[tine20] / tests / tine20 / Calendar / Controller / EventGrantsTests.php
1 <?php
2 /**
3  * Tine 2.0 - http://www.tine20.org
4  * 
5  * @package     Calendar
6  * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
7  * @copyright   Copyright (c) 2009-2013 Metaways Infosystems GmbH (http://www.metaways.de)
8  * @author      Cornelius Weiss <c.weiss@metaways.de>
9  */
10
11 /**
12  * Test helper
13  */
14 require_once dirname(dirname(dirname(__FILE__))) . DIRECTORY_SEPARATOR . 'TestHelper.php';
15
16 /**
17  * Test class for Calendar_Controller_Event
18  * 
19  * @todo:
20  *  - add free/busy cleanup tests
21  * 
22  * @package     Calendar
23  */
24 class Calendar_Controller_EventGrantsTests extends Calendar_TestCase
25 {
26     
27     /**
28      * @var Calendar_Controller_Event controller unter test
29      */
30     protected $_uit;
31     
32     public function setUp()
33     {
34         parent::setUp();
35         
36         /**
37          * set up personas personal container grants:
38          * 
39          *  jsmith:    anyone freebusyGrant, readGrant, addGrant, editGrant, deleteGrant
40          *  pwulf:     anyone readGrant, sclever addGrant, readGrant, editGrant, deleteGrant, privateGrant
41          *  sclever:   testuser addGrant, readGrant, editGrant, deleteGrant, privateGrant
42          *  jmcblack:  prim group of testuser readGrant, testuser privateGrant
43          *  rwright:   testuser freebusyGrant, sclever has readGrant and editGrant
44          */
45         $this->_setupTestCalendars();
46         
47         $this->_uit = Calendar_Controller_Event::getInstance();
48     }
49     
50     public function tearDown()
51     {
52         parent::tearDown();
53         
54         if (! $this->_transactionId) {
55             $this->cleanupTestCalendars();
56         }
57     }
58     
59     /**
60      * a new personal container schould give free/busy to anyone
61      */
62     public function testAddPersonalCalendarGrants()
63     {
64         $grants = Tinebase_Container::getInstance()->getGrantsOfContainer($this->_testCalendar->getId(), TRUE);
65         $anyoneIdx = array_search(Tinebase_Acl_Rights::ACCOUNT_TYPE_ANYONE, $grants->account_type);
66         $this->assertTrue($anyoneIdx !== false, 'anyone has no grant entry');
67         $this->assertTrue($grants[$anyoneIdx]->{Tinebase_Model_Grants::GRANT_FREEBUSY}, 'anyone has not freebusy grant');
68     }
69     
70     /**
71      * reads an event of the personal calendar of jsmith
72      *  -> anyone has readGrant, editGrant and deleteGrant
73      */
74     public function testGrantsByContainerAnyone()
75     {
76         $persistentEvent = $this->_createEventInPersonasCalendar('jsmith', 'jsmith', 'jsmith');
77         
78         $loadedEvent = $this->_uit->get($persistentEvent->getId());
79         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
80         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT});
81         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE});
82     }
83     
84     /**
85      * reads an event of the personal calendar of sclever
86      *  -> test user has readGrant, editGrant and deleteGrant
87      */
88     public function testGrantsByContainerUser()
89     {
90         $persistentEvent = $this->_createEventInPersonasCalendar('sclever', 'sclever', 'sclever');
91         
92         $loadedEvent = $this->_uit->get($persistentEvent->getId());
93         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
94         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT});
95         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE});
96     }
97     
98     /**
99      * reads an event of the personal calendar of jmcblack
100      *  -> default group of testuser has readGrant
101      */
102     public function testGrantsByContainerGroup()
103     {
104         $persistentEvent = $this->_createEventInPersonasCalendar('jmcblack', 'jmcblack', 'jmcblack');
105         
106         $loadedEvent = $this->_uit->get($persistentEvent->getId());
107         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
108         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT});
109         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE});
110     }
111     
112     /**
113      * try to read an event of the personal calendar of rwright
114      *  -> no access
115      */
116     public function testReadGrantByContainerFail()
117     {
118         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', 'rwright');
119         
120         $this->setExpectedException('Tinebase_Exception_AccessDenied');
121         $loadedEvent = $this->_uit->get($persistentEvent->getId());
122     }
123     
124     /**
125      * reads an event of the personal calendar of rwight
126      *  -> test user is attender with implicit readGrant
127      *  -> test user can update his status
128      *  -> test user can delete
129      */
130     public function testGrantsByAttender()
131     {
132         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', NULL);
133         
134         // try read
135         $loadedEvent = $this->_uit->get($persistentEvent->getId());
136         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
137         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT});
138         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE});
139         
140         // try status update
141         $loadedEvent->attendee[0]->status = Calendar_Model_Attender::STATUS_ACCEPTED;
142         $this->_uit->update($loadedEvent);
143         $loadedEvent = $this->_uit->get($persistentEvent->getId());
144         $this->assertEquals(Calendar_Model_Attender::STATUS_ACCEPTED, $loadedEvent->attendee[0]->status);
145         
146         // try delete (implicit DECLINE atm.
147         $this->_uit->delete($persistentEvent->getId());
148         $loadedEvent = $this->_uit->get($persistentEvent->getId());
149         $this->assertEquals(Calendar_Model_Attender::STATUS_DECLINED, $loadedEvent->attendee[0]->status);
150     }
151     
152     /**
153      * reads an event of the personal calendar of rwright
154      *  -> set testuser to organizer! -> implicit readGrand and editGrant
155      */
156     public function testGrantsByOrganizer()
157     {
158         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', NULL, 'rwright');
159         
160         $loadedEvent = $this->_uit->get($persistentEvent->getId());
161         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
162         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT}, Tinebase_Model_Grants::GRANT_EDIT);
163         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE}, Tinebase_Model_Grants::GRANT_DELETE);
164     }
165     
166     /**
167      * reads an event of the personal calendar of rwright
168      *  -> sclever is attender -> testuser has readGrant for scelver
169      */
170     public function testGrantsByInheritedAttendeeContainerGrantsGet()
171     {
172         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', 'sclever');
173         
174         $loadedEvent = $this->_uit->get($persistentEvent->getId());
175         
176         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
177     }
178     
179     /**
180      * searches an event of the personal calendar of rwright
181      *  -> sclever is attender -> testuser has readGrant for scelver
182      */
183     public function testGrantsByInheritedAttendeeContainerGrantsSearch()
184     {
185         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', 'sclever');
186         
187         $loadedEvent = $this->_uit->search(new Calendar_Model_EventFilter(array(
188             array('field' => 'container_id', 'operator' => 'equals', 'value' => "/personal/{$this->_personas['sclever']->getId()}"),
189             array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId())
190         )))->getFirstRecord();
191         
192         $this->assertEquals(1, count($loadedEvent), 'event not found with search action!');
193         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_READ}, 'event not readable');
194         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
195     }
196     
197     /**
198      * try to get/search event of rwright
199      *  -> testuser has no Grants, but freebusy
200      */
201     public function testGrantsByFreeBusy()
202     {
203         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', 'rwright');
204         
205         $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
206             array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId())
207         )));
208         
209         $event = $events->getFirstRecord();
210         
211         $this->assertFalse(empty($event), 'no event found, but freebusy info should be');
212         $this->assertTrue(empty($event->summary), 'event with freebusy only is not cleaned up');
213         $this->assertFalse((bool)$event->{Tinebase_Model_Grants::GRANT_READ}, Tinebase_Model_Grants::GRANT_READ);
214         $this->assertFalse((bool)$event->{Tinebase_Model_Grants::GRANT_EDIT}, Tinebase_Model_Grants::GRANT_EDIT);
215         $this->assertFalse((bool)$event->{Tinebase_Model_Grants::GRANT_DELETE}, Tinebase_Model_Grants::GRANT_DELETE);
216         
217         // direct get of freebusy only events is not allowed
218         $this->setExpectedException('Tinebase_Exception_AccessDenied');
219         $loadedEvent = $this->_uit->get($persistentEvent->getId());
220     }
221     
222     /**
223      * reads an private event of jmcblack
224      *  -> test user has private grant
225      */
226     public function testPrivateViaContainer()
227     {
228         $persistentEvent = $this->_createEventInPersonasCalendar('jmcblack', 'jmcblack', 'jmcblack', Calendar_Model_Event::CLASS_PRIVATE);
229         $loadedEvent = $this->_uit->get($persistentEvent->getId());
230         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
231         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_READ}, Tinebase_Model_Grants::GRANT_READ);
232         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE}, Tinebase_Model_Grants::GRANT_DELETE);
233     }
234     
235     /**
236      * attempt to read an private event of pwulf
237      *  -> test user has no private grant
238      */
239     public function testPrivateViaContainerFail()
240     {
241         $persistentEvent = $this->_createEventInPersonasCalendar('pwulf', 'pwulf', 'pwulf', Calendar_Model_Event::CLASS_PRIVATE);
242         
243         $this->setExpectedException('Tinebase_Exception_AccessDenied');
244         $loadedEvent = $this->_uit->get($persistentEvent->getId());
245     }
246     
247     /**
248      * reads an private event of rwright with testuser as attender
249      *  -> test user should have implicit read grant
250      */
251     public function testPrivateViaAttendee()
252     {
253         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', NULL, Calendar_Model_Event::CLASS_PRIVATE);
254         $loadedEvent = $this->_uit->get($persistentEvent->getId());
255         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
256         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_READ});
257         $this->assertFalse((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT});
258     }
259     
260     /**
261      * reads an private event of rwright with testuser as organizer
262      *  -> test user should have implicit read+edit grant
263      */
264     public function testPrivateViaOrganizer()
265     {
266         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', NULL, 'rwright', Calendar_Model_Event::CLASS_PRIVATE);
267         $loadedEvent = $this->_uit->get($persistentEvent->getId());
268         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
269         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_READ}, Tinebase_Model_Grants::GRANT_READ);
270         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_EDIT}, Tinebase_Model_Grants::GRANT_EDIT);
271         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_DELETE}, Tinebase_Model_Grants::GRANT_DELETE);
272     }
273     
274     /**
275      * reads an private event of pwulf and sclever
276      *  -> test user has private grant for sclever
277      */
278     public function testPrivateViaAttendeeInherritance()
279     {
280         $persistentEvent = $this->_createEventInPersonasCalendar('pwulf', 'pwulf', 'sclever', Calendar_Model_Event::CLASS_PRIVATE);
281         $loadedEvent = $this->_uit->get($persistentEvent->getId());
282         $this->assertEquals($persistentEvent->summary, $loadedEvent->summary);
283         $this->assertTrue((bool)$loadedEvent->{Tinebase_Model_Grants::GRANT_READ});
284     }
285     
286     /**
287      * search an private event of pwulf
288      *  -> test user has no private grant -> must be freebusy cleaned!
289      */
290     public function testPrivateCleanup()
291     {
292         $this->_assertPrivateEvent();
293     }
294     
295     /**
296      * assert private event
297      * 
298      * @param string $searchMethod
299      * @throws InvalidArgumentException
300      */
301     protected function _assertPrivateEvent($searchMethod = 'search')
302     {
303         $persistentEvent = $this->_createEventInPersonasCalendar('pwulf', 'pwulf', 'pwulf', Calendar_Model_Event::CLASS_PRIVATE);
304         
305         if ($searchMethod === 'search') {
306             $filterData = array(
307                 array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId())
308             );
309             $events = $this->_uit->search(new Calendar_Model_EventFilter($filterData), NULL, FALSE, FALSE);
310             
311             // assert json fe does not add history
312             $json = new Calendar_Frontend_Json();
313             $resolvedEvents = $json->searchEvents($filterData, array());
314             $this->assertTrue(empty($resolvedEvents['results'][0]['notes']));
315             
316         } else if ($searchMethod === 'getMultiple') {
317             $events = $this->_uit->getMultiple(array($persistentEvent->getId()));
318         } else {
319             throw new InvalidArgumentException('unknown search method: ' . $searchMethod);
320         }
321         
322         $this->assertTrue($events[0]->summary == '');
323     }
324     
325     /**
326      * testPrivateCleanupGetMultiple
327      * 
328      * @see 0005400: private must lever out admin grant on get/Multiple in controller
329      */
330     public function testPrivateCleanupGetMultiple()
331     {
332         $this->_assertPrivateEvent('getMultiple');
333     }
334     
335     /**
336      * jmcblack organises with rwright
337      *  => testuser shuld see freebusy of rwright
338      *  
339      *  @see #6388: freebusy info missing if user has only access to display calendar
340      */
341     public function testFreeBusyViaAttendee()
342     {
343         // whipe grants from jmcblack
344         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['jmcblack'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
345             'account_id'    => $this->_personas['jmcblack']->getId(),
346             'account_type'  => 'user',
347             Tinebase_Model_Grants::GRANT_READ     => true,
348             Tinebase_Model_Grants::GRANT_ADD      => true,
349             Tinebase_Model_Grants::GRANT_EDIT     => true,
350             Tinebase_Model_Grants::GRANT_DELETE   => true,
351             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
352             Tinebase_Model_Grants::GRANT_ADMIN    => true,
353             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
354         ))), TRUE);
355         
356         $persistentEvent = $this->_createEventInPersonasCalendar('jmcblack', 'jmcblack', 'rwright');
357         
358         $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
359             array('condition' => 'OR', 'filters' => array(
360                 array('condition' => 'AND', 'filters' =>
361                     array(
362                         array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId()),
363                         array('field' => 'attender', 'operator' => 'in', 'value' => array(array(
364                             'user_type' => 'user',
365                             'user_id'   => $this->_personas['rwright']->contact_id,
366                         ))),
367                     )
368                 )
369             ))
370         )), NULL, FALSE, FALSE);
371         
372         $this->assertEquals(1, count($events), 'failed to search fb event');
373     }
374 //    /**
375 //     * search for an attender we have no cal grants for
376 //     * 
377 //     */
378 //    public function testSearchGrantsByAttender()
379 //    {
380 //        // make sure we have no grants on sclevers calendar @ all
381 //        $this->cleanupTestCalendars();
382 //        
383 //        $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright', 'rwright');
384 //        
385 //        $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
386 //            array('field' => 'attender', 'operator' => 'in', 'value' => array(
387 //                array(
388 //                    'user_type' => Calendar_Model_Attender::USERTYPE_USER,
389 //                    'user_id'   => $this->_personasContacts['rwright']->getId()
390 //                )
391 //            ))
392 //        )), NULL, FALSE, FALSE);
393 //        
394 //        print_r($events->toArray());
395 //    }
396
397     /**
398      * tests if search deals with record based grants correctly for 'get' action
399      * 
400      *  -> test user is attendee -> implicit READ GRANT
401      *  
402      */
403     public function testSearchGrantsActionGet()
404     {
405         $events = $this->_testSearchGrantsActionForAction('get');
406         
407         $this->assertEquals(1, count($events), 'testuser has implicit readGrant, but serach for action get found no event');
408     }
409     
410     /**
411      * tests if search deals with record based grants correctly for 'get' action
412      * 
413      *  -> test user is attendee -> implicit SYNC GRANT
414      *  
415      */
416     public function testSearchGrantsActionSync()
417     {
418         $events = $this->_testSearchGrantsActionForAction('sync');
419         
420         $this->assertEquals(1, count($events), 'testuser has implicit syncGrant, but serach for action sync found no event');
421     }
422     
423     protected function _testSearchGrantsActionForAction($_action)
424     {
425         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright');
426         
427         // for shure, this is esoteric, but it enshures that record GRANTS are in charge
428         Tinebase_Container::getInstance()->setGrants($this->_testCalendar, new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
429             'account_id'    => Tinebase_Core::getUser()->getId(),
430             'account_type'  => 'user',
431             Tinebase_Model_Grants::GRANT_FREEBUSY => FALSE,
432             Tinebase_Model_Grants::GRANT_READ     => FALSE,
433             Tinebase_Model_Grants::GRANT_ADD      => FALSE,
434             Tinebase_Model_Grants::GRANT_EDIT     => FALSE,
435             Tinebase_Model_Grants::GRANT_DELETE   => FALSE,
436             Tinebase_Model_Grants::GRANT_PRIVATE  => FALSE,
437             Tinebase_Model_Grants::GRANT_SYNC     => FALSE,
438             Tinebase_Model_Grants::GRANT_EXPORT   => FALSE,
439             Tinebase_Model_Grants::GRANT_ADMIN    => TRUE,
440         ))), TRUE);
441         
442         $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
443             array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId())
444         )), NULL, FALSE, FALSE, $_action);
445         
446         return $events;
447     }
448     
449     /**
450      * tests if search deals with record based grants correctly for 'update' action
451      * 
452      *  -> test user is attendee -> implicit READ GRANT
453      *  
454      */
455     public function testSearchGrantsActionUpdate()
456     {
457         $persistentEvent = $this->_createEventInPersonasCalendar('rwright', 'rwright');
458         
459         $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
460             array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId())
461         )), NULL, FALSE, FALSE, 'update');
462         
463         // the admin grant of testuser of his displaycalendar let this test fail...
464         // in summaray record grants are not taken into account...
465         $this->assertEquals(0, count($events), 'testuser has not edit grant, but serach for action update found the event');
466     }
467     
468     public function testCreateRecurExceptionWithEditGrantOnly()
469     {
470         $this->markTestIncomplete('temporarily disabled until fixed');
471         
472         // set testuser to have editgrant for sclever
473         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['sclever'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
474             'account_id'    => $this->_personas['sclever']->getId(),
475             'account_type'  => 'user',
476             Tinebase_Model_Grants::GRANT_READ     => true,
477             Tinebase_Model_Grants::GRANT_ADD      => true,
478             Tinebase_Model_Grants::GRANT_EDIT     => true,
479             Tinebase_Model_Grants::GRANT_DELETE   => true,
480             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
481             Tinebase_Model_Grants::GRANT_ADMIN    => true,
482             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
483         ), array(
484             'account_id'    => Tinebase_Core::getUser()->getId(),
485             'account_type'  => 'user',
486             Tinebase_Model_Grants::GRANT_READ     => false,
487             Tinebase_Model_Grants::GRANT_ADD      => false,
488             Tinebase_Model_Grants::GRANT_EDIT     => true,
489             Tinebase_Model_Grants::GRANT_DELETE   => false,
490             Tinebase_Model_Grants::GRANT_PRIVATE  => false,
491             Tinebase_Model_Grants::GRANT_ADMIN    => false,
492             Tinebase_Model_Grants::GRANT_FREEBUSY => false,
493         ))), TRUE);
494         
495         $persistentEvent = $this->_createEventInPersonasCalendar('sclever', 'sclever');
496         $persistentEvent->rrule = 'FREQ=DAILY;INTERVAL=1';
497         $updatedEvent = $this->_uit->update($persistentEvent);
498         
499         $events = $this->_uit->search(new Calendar_Model_EventFilter(array(
500             array('field' => 'id', 'operator' => 'equals', 'value' => $persistentEvent->getId()),
501         )), NULL, FALSE, FALSE);
502         
503         $this->assertEquals(1, count($events), 'failed to search fb event');
504         
505         Calendar_Model_Rrule::mergeRecurrenceSet($events, $updatedEvent->dtstart, $updatedEvent->dtstart->getClone()->addDay(7));
506         
507         $this->assertEquals(8, count($events), 'failed to merge recurrence set');
508         
509         $events[3]->summary = 'exception';
510         $exception = $this->_uit->createRecurException($events[3]);
511         
512         $this->assertEquals('exception', $exception->summary);
513     }
514     
515     protected function _createEventInPersonasCalendar($_calendarPersona, $_organizerPersona = NULL, $_attenderPersona = NULL, $_classification = Calendar_Model_Event::CLASS_PUBLIC)
516     {
517         $calendarId  = $this->_personasDefaultCals[$_calendarPersona]->getId();
518         $organizerId = $_organizerPersona ? $this->_personasContacts[$_organizerPersona]->getId() : $this->_testUserContact->getId();
519         $attenderId  = $_attenderPersona ? $this->_personasContacts[$_attenderPersona]->getId() : $this->_testUserContact->getId();
520         
521         $event = $this->_getEvent();
522         $event->class = $_classification;
523         $event->attendee = new Tinebase_Record_RecordSet('Calendar_Model_Attender', array(
524             array(
525                 'user_id'        => $attenderId,
526                 'role'           => Calendar_Model_Attender::ROLE_REQUIRED,
527                 'status_authkey' => Tinebase_Record_Abstract::generateUID(),
528             )
529         ));
530         $persistentEvent = $this->_uit->create($event);
531         
532         // we need to adopt conainer through backend, to bypass rights control
533         $persistentEvent->container_id = $calendarId;
534         $persistentEvent->organizer = $organizerId;
535         $this->_backend->update($persistentEvent);
536         
537         return $persistentEvent;
538     }
539     
540     /**
541      * set up personas personal container grants:
542      * 
543      *  jsmith:    anyone freebusyGrant, readGrant, addGrant, editGrant, deleteGrant
544      *  pwulf:     anyone readGrant, sclever addGrant, readGrant, editGrant, deleteGrant, privateGrant
545      *  sclever:   testuser addGrant, readGrant, editGrant, deleteGrant, privateGrant
546      *  jmcblack:  prim group of testuser readGrant, testuser privateGrant
547      *  rwright:   testuser freebusyGrant, sclever has readGrant and editGrant
548      */
549     protected function _setupTestCalendars()
550     {
551         // jsmith:     anyone freebusyGrant, readGrant, addGrant, editGrant, deleteGrant
552         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['jsmith'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
553             'account_id'    => $this->_personas['jsmith']->getId(),
554             'account_type'  => 'user',
555             Tinebase_Model_Grants::GRANT_READ     => true,
556             Tinebase_Model_Grants::GRANT_ADD      => true,
557             Tinebase_Model_Grants::GRANT_EDIT     => true,
558             Tinebase_Model_Grants::GRANT_DELETE   => true,
559             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
560             Tinebase_Model_Grants::GRANT_ADMIN    => true,
561             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
562         ), array(
563             'account_id'    => 0,
564             'account_type'  => 'anyone',
565             Tinebase_Model_Grants::GRANT_READ     => true,
566             Tinebase_Model_Grants::GRANT_ADD      => true,
567             Tinebase_Model_Grants::GRANT_EDIT     => true,
568             Tinebase_Model_Grants::GRANT_DELETE   => true,
569             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
570             Tinebase_Model_Grants::GRANT_ADMIN    => false,
571         ))), true);
572         
573         // pwulf:      anyone readGrant, sclever addGrant, readGrant, editGrant, deleteGrant, privateGrant
574         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['pwulf'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
575             'account_id'    => $this->_personas['pwulf']->getId(),
576             'account_type'  => 'user',
577             Tinebase_Model_Grants::GRANT_READ     => true,
578             Tinebase_Model_Grants::GRANT_ADD      => true,
579             Tinebase_Model_Grants::GRANT_EDIT     => true,
580             Tinebase_Model_Grants::GRANT_DELETE   => true,
581             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
582             Tinebase_Model_Grants::GRANT_ADMIN    => true,
583             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
584         ), array(
585             'account_id'    => 0,
586             'account_type'  => 'anyone',
587             Tinebase_Model_Grants::GRANT_READ     => true,
588             Tinebase_Model_Grants::GRANT_ADD      => false,
589             Tinebase_Model_Grants::GRANT_EDIT     => false,
590             Tinebase_Model_Grants::GRANT_DELETE   => false,
591             Tinebase_Model_Grants::GRANT_ADMIN    => false,
592         ), array(
593             'account_id'    => $this->_personas['sclever']->getId(),
594             'account_type'  => 'user',
595             Tinebase_Model_Grants::GRANT_READ     => true,
596             Tinebase_Model_Grants::GRANT_ADD      => true,
597             Tinebase_Model_Grants::GRANT_EDIT     => true,
598             Tinebase_Model_Grants::GRANT_DELETE   => true,
599             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
600             Tinebase_Model_Grants::GRANT_ADMIN    => false,
601         ))), true);
602         
603         // sclever:   testuser addGrant, readGrant, editGrant, deleteGrant, privateGrant
604         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['sclever'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
605             'account_id'    => $this->_personas['sclever']->getId(),
606             'account_type'  => 'user',
607             Tinebase_Model_Grants::GRANT_READ     => true,
608             Tinebase_Model_Grants::GRANT_ADD      => true,
609             Tinebase_Model_Grants::GRANT_EDIT     => true,
610             Tinebase_Model_Grants::GRANT_DELETE   => true,
611             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
612             Tinebase_Model_Grants::GRANT_ADMIN    => true,
613             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
614         ),array(
615             'account_id'    => Tinebase_Core::getUser()->getId(),
616             'account_type'  => 'user',
617             Tinebase_Model_Grants::GRANT_READ     => true,
618             Tinebase_Model_Grants::GRANT_ADD      => true,
619             Tinebase_Model_Grants::GRANT_EDIT     => true,
620             Tinebase_Model_Grants::GRANT_DELETE   => true,
621             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
622             Tinebase_Model_Grants::GRANT_ADMIN    => false,
623         ))), true);
624         
625         // jmacblack: prim group of testuser readGrant, testuser privateGrant
626         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['jmcblack'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
627             'account_id'    => $this->_personas['jmcblack']->getId(),
628             'account_type'  => 'user',
629             Tinebase_Model_Grants::GRANT_READ     => true,
630             Tinebase_Model_Grants::GRANT_ADD      => true,
631             Tinebase_Model_Grants::GRANT_EDIT     => true,
632             Tinebase_Model_Grants::GRANT_DELETE   => true,
633             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
634             Tinebase_Model_Grants::GRANT_ADMIN    => true,
635             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
636         ),array(
637             'account_id'    => Tinebase_Core::getUser()->getId(),
638             'account_type'  => 'user',
639             Tinebase_Model_Grants::GRANT_READ     => true,
640             Tinebase_Model_Grants::GRANT_ADD      => false,
641             Tinebase_Model_Grants::GRANT_EDIT     => false,
642             Tinebase_Model_Grants::GRANT_DELETE   => false,
643             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
644             Tinebase_Model_Grants::GRANT_ADMIN    => false,
645         ),array(
646             'account_id'    => Tinebase_Core::getUser()->accountPrimaryGroup,
647             'account_type'  => 'group',
648             Tinebase_Model_Grants::GRANT_READ     => true,
649             Tinebase_Model_Grants::GRANT_ADD      => false,
650             Tinebase_Model_Grants::GRANT_EDIT     => false,
651             Tinebase_Model_Grants::GRANT_DELETE   => false,
652             Tinebase_Model_Grants::GRANT_ADMIN    => false,
653         ))), true);
654         
655         // rwright:   testuser freebusyGrant, sclever has readGrant and editGrant
656         Tinebase_Container::getInstance()->setGrants($this->_personasDefaultCals['rwright'], new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
657             'account_id'    => $this->_personas['rwright']->getId(),
658             'account_type'  => 'user',
659             Tinebase_Model_Grants::GRANT_READ     => true,
660             Tinebase_Model_Grants::GRANT_ADD      => true,
661             Tinebase_Model_Grants::GRANT_EDIT     => true,
662             Tinebase_Model_Grants::GRANT_DELETE   => true,
663             Tinebase_Model_Grants::GRANT_PRIVATE  => true,
664             Tinebase_Model_Grants::GRANT_ADMIN    => true,
665             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
666         ),array(
667             'account_id'    => Tinebase_Core::getUser()->getId(),
668             'account_type'  => 'user',
669             Tinebase_Model_Grants::GRANT_READ     => false,
670             Tinebase_Model_Grants::GRANT_ADD      => false,
671             Tinebase_Model_Grants::GRANT_EDIT     => false,
672             Tinebase_Model_Grants::GRANT_DELETE   => false,
673             Tinebase_Model_Grants::GRANT_PRIVATE  => false,
674             Tinebase_Model_Grants::GRANT_ADMIN    => false,
675             Tinebase_Model_Grants::GRANT_FREEBUSY => true,
676         ), array(
677             'account_id'    => $this->_personas['sclever']->getId(),
678             'account_type'  => 'user',
679             Tinebase_Model_Grants::GRANT_READ     => true,
680             Tinebase_Model_Grants::GRANT_ADD      => false,
681             Tinebase_Model_Grants::GRANT_EDIT     => true,
682             Tinebase_Model_Grants::GRANT_DELETE   => false,
683             Tinebase_Model_Grants::GRANT_ADMIN    => false,
684         ))), true);
685     }
686     
687     /**
688      * resets all grants of personas calendars and deletes events from it
689      */
690     protected function cleanupTestCalendars()
691     {
692         foreach ($this->_personasDefaultCals as $loginName => $calendar) {
693             Tinebase_Container::getInstance()->setGrants($calendar, new Tinebase_Record_RecordSet('Tinebase_Model_Grants', array(array(
694                 'account_id'    => $this->_personas[$loginName]->getId(),
695                 'account_type'  => 'user',
696                 Tinebase_Model_Grants::GRANT_READ     => true,
697                 Tinebase_Model_Grants::GRANT_ADD      => true,
698                 Tinebase_Model_Grants::GRANT_EDIT     => true,
699                 Tinebase_Model_Grants::GRANT_DELETE   => true,
700                 Tinebase_Model_Grants::GRANT_PRIVATE  => true,
701                 Tinebase_Model_Grants::GRANT_ADMIN    => true,
702             ))), true);
703             
704             $events = $this->_backend->search(new Calendar_Model_EventFilter(array(
705                 array('field' => 'container_id', 'operator' => 'equals', 'value' => $calendar->getId()),
706             )), new Tinebase_Model_Pagination(array()));
707             
708             // delete alarms
709             Tinebase_Alarm::getInstance()->deleteAlarmsOfRecord('Calendar_Model_Event', $events->getArrayOfIds());
710             
711             // delete events
712             foreach ($events as $event) {
713                 $this->_backend->delete($event->getId());
714             }
715         }
716     }
717 }