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