nextcloud / server

tests/lib/Calendar/ManagerTest.php

Indentation +732 added lines, -732 removed lines

@@ -42,603 +42,603 @@ 
 }
 
 class ManagerTest extends TestCase {
-	/** @var Coordinator&MockObject */
-	private $coordinator;
-
-	/** @var ContainerInterface&MockObject */
-	private $container;
-
-	/** @var LoggerInterface&MockObject */
-	private $logger;
-
-	/** @var Manager */
-	private $manager;
-
-	/** @var ITimeFactory&MockObject */
-	private $time;
-
-	/** @var ISecureRandom&MockObject */
-	private ISecureRandom $secureRandom;
-
-	private IUserManager&MockObject $userManager;
-	private ServerFactory&MockObject $serverFactory;
-	private PropertyMapper&MockObject $propertyMapper;
-
-	private VCalendar $vCalendar1a;
-	private VCalendar $vCalendar2a;
-	private VCalendar $vCalendar3a;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->coordinator = $this->createMock(Coordinator::class);
-		$this->container = $this->createMock(ContainerInterface::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->time = $this->createMock(ITimeFactory::class);
-		$this->secureRandom = $this->createMock(ISecureRandom::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->serverFactory = $this->createMock(ServerFactory::class);
-		$this->propertyMapper = $this->createMock(PropertyMapper::class);
-
-		$this->manager = new Manager(
-			$this->coordinator,
-			$this->container,
-			$this->logger,
-			$this->time,
-			$this->secureRandom,
-			$this->userManager,
-			$this->serverFactory,
-			$this->propertyMapper,
-		);
-
-		// construct calendar with a 1 hour event and same start/end time zones
-		$this->vCalendar1a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar1a->add('VEVENT', []);
-		$vEvent->UID->setValue('96a0e6b1-d886-4a55-a60d-152b31401dcc');
-		$vEvent->add('DTSTART', '20240701T080000', ['TZID' => 'America/Toronto']);
-		$vEvent->add('DTEND', '20240701T090000', ['TZID' => 'America/Toronto']);
-		$vEvent->add('SUMMARY', 'Test Event');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CONFIRMED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:organizer@testing.com', ['CN' => 'Organizer']);
-		$vEvent->add('ATTENDEE', 'mailto:attendee1@testing.com', [
-			'CN' => 'Attendee One',
-			'CUTYPE' => 'INDIVIDUAL',
-			'PARTSTAT' => 'NEEDS-ACTION',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'RSVP' => 'TRUE'
-		]);
-
-		// construct calendar with a event for reply
-		$this->vCalendar2a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar2a->add('VEVENT', []);
-		$vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
-		$vEvent->add('DTSTART', '20210820');
-		$vEvent->add('DTEND', '20220821');
-		$vEvent->add('SUMMARY', 'berry basket');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CONFIRMED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
-		$vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
-			'CN' => 'pierre@general-store.com',
-			'CUTYPE' => 'INDIVIDUAL',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'PARTSTAT' => 'ACCEPTED',
-		]);
-
-		// construct calendar with a event for reply
-		$this->vCalendar3a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar3a->add('VEVENT', []);
-		$vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
-		$vEvent->add('DTSTART', '20210820');
-		$vEvent->add('DTEND', '20220821');
-		$vEvent->add('SUMMARY', 'berry basket');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CANCELLED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
-		$vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
-			'CN' => 'pierre@general-store.com',
-			'CUTYPE' => 'INDIVIDUAL',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'PARTSTAT' => 'ACCEPTED',
-		]);
-
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
-	public function testSearch($search1, $search2, $expected): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('simple:1');
-		$calendar1->expects($this->once())
-			->method('search')
-			->with('', [], [], null, null)
-			->willReturn($search1);
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('simple:2');
-		$calendar2->expects($this->once())
-			->method('search')
-			->with('', [], [], null, null)
-			->willReturn($search2);
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->search('');
-		$this->assertEquals($expected, $result);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
-	public function testSearchOptions($search1, $search2, $expected): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('simple:1');
-		$calendar1->expects($this->once())
-			->method('search')
-			->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-				['timerange' => ['start' => null, 'end' => null]], 5, 20)
-			->willReturn($search1);
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('simple:2');
-		$calendar2->expects($this->once())
-			->method('search')
-			->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-				['timerange' => ['start' => null, 'end' => null]], 5, 20)
-			->willReturn($search2);
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->search('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-			['timerange' => ['start' => null, 'end' => null]], 5, 20);
-		$this->assertEquals($expected, $result);
-	}
-
-	public static function searchProvider(): array {
-		$search1 = [
-			[
-				'id' => 1,
-				'data' => 'foobar',
-			],
-			[
-				'id' => 2,
-				'data' => 'barfoo',
-			]
-		];
-		$search2 = [
-			[
-				'id' => 3,
-				'data' => 'blablub',
-			],
-			[
-				'id' => 4,
-				'data' => 'blubbla',
-			]
-		];
-
-		$expected = [
-			[
-				'id' => 1,
-				'data' => 'foobar',
-				'calendar-key' => 'simple:1',
-			],
-			[
-				'id' => 2,
-				'data' => 'barfoo',
-				'calendar-key' => 'simple:1',
-			],
-			[
-				'id' => 3,
-				'data' => 'blablub',
-				'calendar-key' => 'simple:2',
-			],
-			[
-				'id' => 4,
-				'data' => 'blubbla',
-				'calendar-key' => 'simple:2',
-			]
-		];
-
-		return [
-			[
-				$search1,
-				$search2,
-				$expected
-			]
-		];
-	}
-
-	public function testRegisterUnregister(): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('key1');
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('key2');
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(2, $result);
-		$this->assertContains($calendar1, $result);
-		$this->assertContains($calendar2, $result);
-
-		$this->manager->unregisterCalendar($calendar1);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(1, $result);
-		$this->assertContains($calendar2, $result);
-	}
-
-	public function testGetCalendars(): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('key1');
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('key2');
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(2, $result);
-		$this->assertContains($calendar1, $result);
-		$this->assertContains($calendar2, $result);
-
-		$this->manager->clear();
-
-		$result = $this->manager->getCalendars();
-
-		$this->assertCount(0, $result);
-	}
-
-	public function testEnabledIfNot(): void {
-		$isEnabled = $this->manager->isEnabled();
-		$this->assertFalse($isEnabled);
-	}
-
-	public function testIfEnabledIfSo(): void {
-		/** @var ICalendar | MockObject $calendar */
-		$calendar = $this->createMock(ICalendar::class);
-		$this->manager->registerCalendar($calendar);
-
-		$isEnabled = $this->manager->isEnabled();
-		$this->assertTrue($isEnabled);
-	}
-
-	public function testHandleImipWithNoCalendars(): void {
-		// construct calendar manager returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message could not be processed because user has no calendars');
-		// construct parameters
-		$userId = 'attendee1';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// test method
-		$result = $manager->handleIMip($userId, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipWithNoEvent(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message does not contain any event(s)');
-		// construct parameters
-		$userId = 'attendee1';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->remove('VEVENT');
-		// Act
-		$result = $manager->handleIMip($userId, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipWithNoUid(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains a UID');
-		// construct parameters
-		$userId = 'attendee1';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->VEVENT->remove('UID');
-		// test method
-		$result = $manager->handleIMip($userId, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipWithNoMatch(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('isDeleted')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('isWritable')
-			->willReturn(true);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message could not be processed because no corresponding event was found in any calendar');
-		// construct parameters
-		$userId = 'attendee1';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// test method
-		$result = $manager->handleIMip($userId, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImip(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('isDeleted')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('isWritable')
-			->willReturn(true);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([['uri' => 'principals/user/attendee1/personal']]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct parameters
-		$userId = 'attendee1';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// construct user calendar returns
-		$userCalendar->expects(self::once())
-			->method('handleIMipMessage');
-		// test method
-		$result = $manager->handleIMip($userId, $calendar->serialize());
-	}
-
-	public function testhandleIMipRequestWithInvalidPrincipal() {
-		$invalidPrincipal = 'invalid-principal-uri';
-		$sender = 'sender@example.com';
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar1a->serialize();
-
-		$this->logger->expects(self::once())
-			->method('error')
-			->with('Invalid principal URI provided for iMip request');
-
-		$result = $this->manager->handleIMipRequest($invalidPrincipal, $sender, $recipient, $calendarData);
-		$this->assertFalse($result);
-	}
-
-	public function testhandleIMipRequest() {
-		$principalUri = 'principals/users/attendee1';
-		$sender = 'sender@example.com';
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar1a->serialize();
-
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['handleIMip'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('handleIMip')
-			->with('attendee1', $calendarData)
-			->willReturn(true);
-
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendarData);
-		$this->assertTrue($result);
-	}
-
-	public function testhandleIMipReplyWithInvalidPrincipal() {
-		$invalidPrincipal = 'invalid-principal-uri';
-		$sender = 'sender@example.com';
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar2a->serialize();
-
-		$this->logger->expects(self::once())
-			->method('error')
-			->with('Invalid principal URI provided for iMip reply');
-
-		$result = $this->manager->handleIMipReply($invalidPrincipal, $sender, $recipient, $calendarData);
-		$this->assertFalse($result);
-	}
-
-	public function testhandleIMipReply() {
-		$principalUri = 'principals/users/attendee2';
-		$sender = 'sender@example.com';
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar2a->serialize();
-
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['handleIMip'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('handleIMip')
-			->with('attendee2', $calendarData)
-			->willReturn(true);
-
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData);
-		$this->assertTrue($result);
-	}
-
-	public function testhandleIMipCancelWithInvalidPrincipal() {
-		$invalidPrincipal = 'invalid-principal-uri';
-		$sender = 'sender@example.com';
-		$replyTo = null;
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar3a->serialize();
-
-		$this->logger->expects(self::once())
-			->method('error')
-			->with('Invalid principal URI provided for iMip cancel');
-
-		$result = $this->manager->handleIMipCancel($invalidPrincipal, $sender, $replyTo, $recipient, $calendarData);
-		$this->assertFalse($result);
-	}
-
-	public function testhandleIMipCancel() {
-		$principalUri = 'principals/users/attendee3';
-		$sender = 'sender@example.com';
-		$replyTo = null;
-		$recipient = 'recipient@example.com';
-		$calendarData = $this->vCalendar3a->serialize();
-
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-				$this->propertyMapper,
-			])
-			->onlyMethods(['handleIMip'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('handleIMip')
-			->with('attendee3', $calendarData)
-			->willReturn(true);
-
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData);
-		$this->assertTrue($result);
-	}
-
-	private function getFreeBusyResponse(): string {
-		return <<<EOF
+    /** @var Coordinator&MockObject */
+    private $coordinator;
+
+    /** @var ContainerInterface&MockObject */
+    private $container;
+
+    /** @var LoggerInterface&MockObject */
+    private $logger;
+
+    /** @var Manager */
+    private $manager;
+
+    /** @var ITimeFactory&MockObject */
+    private $time;
+
+    /** @var ISecureRandom&MockObject */
+    private ISecureRandom $secureRandom;
+
+    private IUserManager&MockObject $userManager;
+    private ServerFactory&MockObject $serverFactory;
+    private PropertyMapper&MockObject $propertyMapper;
+
+    private VCalendar $vCalendar1a;
+    private VCalendar $vCalendar2a;
+    private VCalendar $vCalendar3a;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->coordinator = $this->createMock(Coordinator::class);
+        $this->container = $this->createMock(ContainerInterface::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->time = $this->createMock(ITimeFactory::class);
+        $this->secureRandom = $this->createMock(ISecureRandom::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->serverFactory = $this->createMock(ServerFactory::class);
+        $this->propertyMapper = $this->createMock(PropertyMapper::class);
+
+        $this->manager = new Manager(
+            $this->coordinator,
+            $this->container,
+            $this->logger,
+            $this->time,
+            $this->secureRandom,
+            $this->userManager,
+            $this->serverFactory,
+            $this->propertyMapper,
+        );
+
+        // construct calendar with a 1 hour event and same start/end time zones
+        $this->vCalendar1a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar1a->add('VEVENT', []);
+        $vEvent->UID->setValue('96a0e6b1-d886-4a55-a60d-152b31401dcc');
+        $vEvent->add('DTSTART', '20240701T080000', ['TZID' => 'America/Toronto']);
+        $vEvent->add('DTEND', '20240701T090000', ['TZID' => 'America/Toronto']);
+        $vEvent->add('SUMMARY', 'Test Event');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CONFIRMED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:organizer@testing.com', ['CN' => 'Organizer']);
+        $vEvent->add('ATTENDEE', 'mailto:attendee1@testing.com', [
+            'CN' => 'Attendee One',
+            'CUTYPE' => 'INDIVIDUAL',
+            'PARTSTAT' => 'NEEDS-ACTION',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'RSVP' => 'TRUE'
+        ]);
+
+        // construct calendar with a event for reply
+        $this->vCalendar2a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar2a->add('VEVENT', []);
+        $vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
+        $vEvent->add('DTSTART', '20210820');
+        $vEvent->add('DTEND', '20220821');
+        $vEvent->add('SUMMARY', 'berry basket');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CONFIRMED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
+        $vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
+            'CN' => 'pierre@general-store.com',
+            'CUTYPE' => 'INDIVIDUAL',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'PARTSTAT' => 'ACCEPTED',
+        ]);
+
+        // construct calendar with a event for reply
+        $this->vCalendar3a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar3a->add('VEVENT', []);
+        $vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
+        $vEvent->add('DTSTART', '20210820');
+        $vEvent->add('DTEND', '20220821');
+        $vEvent->add('SUMMARY', 'berry basket');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CANCELLED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
+        $vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
+            'CN' => 'pierre@general-store.com',
+            'CUTYPE' => 'INDIVIDUAL',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'PARTSTAT' => 'ACCEPTED',
+        ]);
+
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
+    public function testSearch($search1, $search2, $expected): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('simple:1');
+        $calendar1->expects($this->once())
+            ->method('search')
+            ->with('', [], [], null, null)
+            ->willReturn($search1);
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('simple:2');
+        $calendar2->expects($this->once())
+            ->method('search')
+            ->with('', [], [], null, null)
+            ->willReturn($search2);
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->search('');
+        $this->assertEquals($expected, $result);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
+    public function testSearchOptions($search1, $search2, $expected): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('simple:1');
+        $calendar1->expects($this->once())
+            ->method('search')
+            ->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+                ['timerange' => ['start' => null, 'end' => null]], 5, 20)
+            ->willReturn($search1);
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('simple:2');
+        $calendar2->expects($this->once())
+            ->method('search')
+            ->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+                ['timerange' => ['start' => null, 'end' => null]], 5, 20)
+            ->willReturn($search2);
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->search('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+            ['timerange' => ['start' => null, 'end' => null]], 5, 20);
+        $this->assertEquals($expected, $result);
+    }
+
+    public static function searchProvider(): array {
+        $search1 = [
+            [
+                'id' => 1,
+                'data' => 'foobar',
+            ],
+            [
+                'id' => 2,
+                'data' => 'barfoo',
+            ]
+        ];
+        $search2 = [
+            [
+                'id' => 3,
+                'data' => 'blablub',
+            ],
+            [
+                'id' => 4,
+                'data' => 'blubbla',
+            ]
+        ];
+
+        $expected = [
+            [
+                'id' => 1,
+                'data' => 'foobar',
+                'calendar-key' => 'simple:1',
+            ],
+            [
+                'id' => 2,
+                'data' => 'barfoo',
+                'calendar-key' => 'simple:1',
+            ],
+            [
+                'id' => 3,
+                'data' => 'blablub',
+                'calendar-key' => 'simple:2',
+            ],
+            [
+                'id' => 4,
+                'data' => 'blubbla',
+                'calendar-key' => 'simple:2',
+            ]
+        ];
+
+        return [
+            [
+                $search1,
+                $search2,
+                $expected
+            ]
+        ];
+    }
+
+    public function testRegisterUnregister(): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('key1');
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('key2');
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(2, $result);
+        $this->assertContains($calendar1, $result);
+        $this->assertContains($calendar2, $result);
+
+        $this->manager->unregisterCalendar($calendar1);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(1, $result);
+        $this->assertContains($calendar2, $result);
+    }
+
+    public function testGetCalendars(): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('key1');
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('key2');
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(2, $result);
+        $this->assertContains($calendar1, $result);
+        $this->assertContains($calendar2, $result);
+
+        $this->manager->clear();
+
+        $result = $this->manager->getCalendars();
+
+        $this->assertCount(0, $result);
+    }
+
+    public function testEnabledIfNot(): void {
+        $isEnabled = $this->manager->isEnabled();
+        $this->assertFalse($isEnabled);
+    }
+
+    public function testIfEnabledIfSo(): void {
+        /** @var ICalendar | MockObject $calendar */
+        $calendar = $this->createMock(ICalendar::class);
+        $this->manager->registerCalendar($calendar);
+
+        $isEnabled = $this->manager->isEnabled();
+        $this->assertTrue($isEnabled);
+    }
+
+    public function testHandleImipWithNoCalendars(): void {
+        // construct calendar manager returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message could not be processed because user has no calendars');
+        // construct parameters
+        $userId = 'attendee1';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // test method
+        $result = $manager->handleIMip($userId, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipWithNoEvent(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message does not contain any event(s)');
+        // construct parameters
+        $userId = 'attendee1';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->remove('VEVENT');
+        // Act
+        $result = $manager->handleIMip($userId, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipWithNoUid(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains a UID');
+        // construct parameters
+        $userId = 'attendee1';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->VEVENT->remove('UID');
+        // test method
+        $result = $manager->handleIMip($userId, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipWithNoMatch(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('isDeleted')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('isWritable')
+            ->willReturn(true);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message could not be processed because no corresponding event was found in any calendar');
+        // construct parameters
+        $userId = 'attendee1';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // test method
+        $result = $manager->handleIMip($userId, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImip(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('isDeleted')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('isWritable')
+            ->willReturn(true);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([['uri' => 'principals/user/attendee1/personal']]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct parameters
+        $userId = 'attendee1';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // construct user calendar returns
+        $userCalendar->expects(self::once())
+            ->method('handleIMipMessage');
+        // test method
+        $result = $manager->handleIMip($userId, $calendar->serialize());
+    }
+
+    public function testhandleIMipRequestWithInvalidPrincipal() {
+        $invalidPrincipal = 'invalid-principal-uri';
+        $sender = 'sender@example.com';
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar1a->serialize();
+
+        $this->logger->expects(self::once())
+            ->method('error')
+            ->with('Invalid principal URI provided for iMip request');
+
+        $result = $this->manager->handleIMipRequest($invalidPrincipal, $sender, $recipient, $calendarData);
+        $this->assertFalse($result);
+    }
+
+    public function testhandleIMipRequest() {
+        $principalUri = 'principals/users/attendee1';
+        $sender = 'sender@example.com';
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar1a->serialize();
+
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['handleIMip'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('handleIMip')
+            ->with('attendee1', $calendarData)
+            ->willReturn(true);
+
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendarData);
+        $this->assertTrue($result);
+    }
+
+    public function testhandleIMipReplyWithInvalidPrincipal() {
+        $invalidPrincipal = 'invalid-principal-uri';
+        $sender = 'sender@example.com';
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar2a->serialize();
+
+        $this->logger->expects(self::once())
+            ->method('error')
+            ->with('Invalid principal URI provided for iMip reply');
+
+        $result = $this->manager->handleIMipReply($invalidPrincipal, $sender, $recipient, $calendarData);
+        $this->assertFalse($result);
+    }
+
+    public function testhandleIMipReply() {
+        $principalUri = 'principals/users/attendee2';
+        $sender = 'sender@example.com';
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar2a->serialize();
+
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['handleIMip'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('handleIMip')
+            ->with('attendee2', $calendarData)
+            ->willReturn(true);
+
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData);
+        $this->assertTrue($result);
+    }
+
+    public function testhandleIMipCancelWithInvalidPrincipal() {
+        $invalidPrincipal = 'invalid-principal-uri';
+        $sender = 'sender@example.com';
+        $replyTo = null;
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar3a->serialize();
+
+        $this->logger->expects(self::once())
+            ->method('error')
+            ->with('Invalid principal URI provided for iMip cancel');
+
+        $result = $this->manager->handleIMipCancel($invalidPrincipal, $sender, $replyTo, $recipient, $calendarData);
+        $this->assertFalse($result);
+    }
+
+    public function testhandleIMipCancel() {
+        $principalUri = 'principals/users/attendee3';
+        $sender = 'sender@example.com';
+        $replyTo = null;
+        $recipient = 'recipient@example.com';
+        $calendarData = $this->vCalendar3a->serialize();
+
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+                $this->propertyMapper,
+            ])
+            ->onlyMethods(['handleIMip'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('handleIMip')
+            ->with('attendee3', $calendarData)
+            ->willReturn(true);
+
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData);
+        $this->assertTrue($result);
+    }
+
+    private function getFreeBusyResponse(): string {
+        return <<<EOF
 <?xml version="1.0" encoding="utf-8"?>
 <cal:schedule-response xmlns:d="DAV:" xmlns:s="http://sabredav.org/ns" xmlns:cal="urn:ietf:params:xml:ns:caldav" xmlns:cs="http://calendarserver.org/ns/" xmlns:oc="http://owncloud.org/ns" xmlns:nc="http://nextcloud.org/ns">
   <cal:response>
@@ -716,139 +716,139 @@ 
   </cal:response>
 </cal:schedule-response>
 EOF;
-	}
-
-	public function testCheckAvailability(): void {
-		$organizer = $this->createMock(IUser::class);
-		$organizer->expects(self::once())
-			->method('getUID')
-			->willReturn('admin');
-		$organizer->expects(self::once())
-			->method('getEMailAddress')
-			->willReturn('admin@imap.localhost');
-
-		$user1 = $this->createMock(IUser::class);
-		$user2 = $this->createMock(IUser::class);
-
-		$this->userManager->expects(self::exactly(3))
-			->method('getByEmail')
-			->willReturnMap([
-				['user@imap.localhost', [$user1]],
-				['empty@imap.localhost', [$user2]],
-				['nouser@domain.tld', []],
-			]);
-
-		$authPlugin = $this->createMock(CustomPrincipalPlugin::class);
-		$authPlugin->expects(self::once())
-			->method('setCurrentPrincipal')
-			->with('principals/users/admin');
-
-		$server = $this->createMock(Server::class);
-		$server->expects(self::once())
-			->method('getPlugin')
-			->with('auth')
-			->willReturn($authPlugin);
-		$server->expects(self::once())
-			->method('invokeMethod')
-			->willReturnCallback(function (
-				RequestInterface $request,
-				ResponseInterface $response,
-				bool $sendResponse,
-			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
-				$this->assertEquals('POST', $request->getMethod());
-				$this->assertEquals('calendars/admin/outbox', $request->getPath());
-				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
-				$this->assertEquals('0', $request->getHeader('Depth'));
-				$this->assertEquals($requestBody, $request->getBodyAsString());
-				$this->assertFalse($sendResponse);
-				$response->setStatus(200);
-				$response->setBody($this->getFreeBusyResponse());
-			});
-
-		$this->serverFactory->expects(self::once())
-			->method('createAttendeeAvailabilityServer')
-			->willReturn($server);
-
-		$start = new DateTimeImmutable('2025-01-16T06:00:00Z');
-		$end = new DateTimeImmutable('2025-01-17T06:00:00Z');
-		$actual = $this->manager->checkAvailability($start, $end, $organizer, [
-			'user@imap.localhost',
-			'empty@imap.localhost',
-			'nouser@domain.tld',
-		]);
-		$expected = [
-			new AvailabilityResult('admin@imap.localhost', false),
-			new AvailabilityResult('empty@imap.localhost', true),
-			new AvailabilityResult('user@imap.localhost', false),
-		];
-		$this->assertEquals($expected, $actual);
-	}
-
-	public function testCheckAvailabilityWithMailtoPrefix(): void {
-		$organizer = $this->createMock(IUser::class);
-		$organizer->expects(self::once())
-			->method('getUID')
-			->willReturn('admin');
-		$organizer->expects(self::once())
-			->method('getEMailAddress')
-			->willReturn('admin@imap.localhost');
-
-		$user1 = $this->createMock(IUser::class);
-		$user2 = $this->createMock(IUser::class);
-
-		$this->userManager->expects(self::exactly(3))
-			->method('getByEmail')
-			->willReturnMap([
-				['user@imap.localhost', [$user1]],
-				['empty@imap.localhost', [$user2]],
-				['nouser@domain.tld', []],
-			]);
-
-		$authPlugin = $this->createMock(CustomPrincipalPlugin::class);
-		$authPlugin->expects(self::once())
-			->method('setCurrentPrincipal')
-			->with('principals/users/admin');
-
-		$server = $this->createMock(Server::class);
-		$server->expects(self::once())
-			->method('getPlugin')
-			->with('auth')
-			->willReturn($authPlugin);
-		$server->expects(self::once())
-			->method('invokeMethod')
-			->willReturnCallback(function (
-				RequestInterface $request,
-				ResponseInterface $response,
-				bool $sendResponse,
-			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
-				$this->assertEquals('POST', $request->getMethod());
-				$this->assertEquals('calendars/admin/outbox', $request->getPath());
-				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
-				$this->assertEquals('0', $request->getHeader('Depth'));
-				$this->assertEquals($requestBody, $request->getBodyAsString());
-				$this->assertFalse($sendResponse);
-				$response->setStatus(200);
-				$response->setBody($this->getFreeBusyResponse());
-			});
-
-		$this->serverFactory->expects(self::once())
-			->method('createAttendeeAvailabilityServer')
-			->willReturn($server);
-
-		$start = new DateTimeImmutable('2025-01-16T06:00:00Z');
-		$end = new DateTimeImmutable('2025-01-17T06:00:00Z');
-		$actual = $this->manager->checkAvailability($start, $end, $organizer, [
-			'mailto:user@imap.localhost',
-			'mailto:empty@imap.localhost',
-			'mailto:nouser@domain.tld',
-		]);
-		$expected = [
-			new AvailabilityResult('admin@imap.localhost', false),
-			new AvailabilityResult('empty@imap.localhost', true),
-			new AvailabilityResult('user@imap.localhost', false),
-		];
-		$this->assertEquals($expected, $actual);
-	}
+    }
+
+    public function testCheckAvailability(): void {
+        $organizer = $this->createMock(IUser::class);
+        $organizer->expects(self::once())
+            ->method('getUID')
+            ->willReturn('admin');
+        $organizer->expects(self::once())
+            ->method('getEMailAddress')
+            ->willReturn('admin@imap.localhost');
+
+        $user1 = $this->createMock(IUser::class);
+        $user2 = $this->createMock(IUser::class);
+
+        $this->userManager->expects(self::exactly(3))
+            ->method('getByEmail')
+            ->willReturnMap([
+                ['user@imap.localhost', [$user1]],
+                ['empty@imap.localhost', [$user2]],
+                ['nouser@domain.tld', []],
+            ]);
+
+        $authPlugin = $this->createMock(CustomPrincipalPlugin::class);
+        $authPlugin->expects(self::once())
+            ->method('setCurrentPrincipal')
+            ->with('principals/users/admin');
+
+        $server = $this->createMock(Server::class);
+        $server->expects(self::once())
+            ->method('getPlugin')
+            ->with('auth')
+            ->willReturn($authPlugin);
+        $server->expects(self::once())
+            ->method('invokeMethod')
+            ->willReturnCallback(function (
+                RequestInterface $request,
+                ResponseInterface $response,
+                bool $sendResponse,
+            ): void {
+                $requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+                $this->assertEquals('POST', $request->getMethod());
+                $this->assertEquals('calendars/admin/outbox', $request->getPath());
+                $this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
+                $this->assertEquals('0', $request->getHeader('Depth'));
+                $this->assertEquals($requestBody, $request->getBodyAsString());
+                $this->assertFalse($sendResponse);
+                $response->setStatus(200);
+                $response->setBody($this->getFreeBusyResponse());
+            });
+
+        $this->serverFactory->expects(self::once())
+            ->method('createAttendeeAvailabilityServer')
+            ->willReturn($server);
+
+        $start = new DateTimeImmutable('2025-01-16T06:00:00Z');
+        $end = new DateTimeImmutable('2025-01-17T06:00:00Z');
+        $actual = $this->manager->checkAvailability($start, $end, $organizer, [
+            'user@imap.localhost',
+            'empty@imap.localhost',
+            'nouser@domain.tld',
+        ]);
+        $expected = [
+            new AvailabilityResult('admin@imap.localhost', false),
+            new AvailabilityResult('empty@imap.localhost', true),
+            new AvailabilityResult('user@imap.localhost', false),
+        ];
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function testCheckAvailabilityWithMailtoPrefix(): void {
+        $organizer = $this->createMock(IUser::class);
+        $organizer->expects(self::once())
+            ->method('getUID')
+            ->willReturn('admin');
+        $organizer->expects(self::once())
+            ->method('getEMailAddress')
+            ->willReturn('admin@imap.localhost');
+
+        $user1 = $this->createMock(IUser::class);
+        $user2 = $this->createMock(IUser::class);
+
+        $this->userManager->expects(self::exactly(3))
+            ->method('getByEmail')
+            ->willReturnMap([
+                ['user@imap.localhost', [$user1]],
+                ['empty@imap.localhost', [$user2]],
+                ['nouser@domain.tld', []],
+            ]);
+
+        $authPlugin = $this->createMock(CustomPrincipalPlugin::class);
+        $authPlugin->expects(self::once())
+            ->method('setCurrentPrincipal')
+            ->with('principals/users/admin');
+
+        $server = $this->createMock(Server::class);
+        $server->expects(self::once())
+            ->method('getPlugin')
+            ->with('auth')
+            ->willReturn($authPlugin);
+        $server->expects(self::once())
+            ->method('invokeMethod')
+            ->willReturnCallback(function (
+                RequestInterface $request,
+                ResponseInterface $response,
+                bool $sendResponse,
+            ): void {
+                $requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+                $this->assertEquals('POST', $request->getMethod());
+                $this->assertEquals('calendars/admin/outbox', $request->getPath());
+                $this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
+                $this->assertEquals('0', $request->getHeader('Depth'));
+                $this->assertEquals($requestBody, $request->getBodyAsString());
+                $this->assertFalse($sendResponse);
+                $response->setStatus(200);
+                $response->setBody($this->getFreeBusyResponse());
+            });
+
+        $this->serverFactory->expects(self::once())
+            ->method('createAttendeeAvailabilityServer')
+            ->willReturn($server);
+
+        $start = new DateTimeImmutable('2025-01-16T06:00:00Z');
+        $end = new DateTimeImmutable('2025-01-17T06:00:00Z');
+        $actual = $this->manager->checkAvailability($start, $end, $organizer, [
+            'mailto:user@imap.localhost',
+            'mailto:empty@imap.localhost',
+            'mailto:nouser@domain.tld',
+        ]);
+        $expected = [
+            new AvailabilityResult('admin@imap.localhost', false),
+            new AvailabilityResult('empty@imap.localhost', true),
+            new AvailabilityResult('user@imap.localhost', false),
+        ];
+        $this->assertEquals($expected, $actual);
+    }
 }

lib/private/Calendar/Manager.php

Indentation +450 added lines, -450 removed lines

@@ -41,455 +41,455 @@
 use function array_merge;
 
 class Manager implements IManager {
-	/**
-	 * @var ICalendar[] holds all registered calendars
-	 */
-	private array $calendars = [];
-
-	/**
-	 * @var \Closure[] to call to load/register calendar providers
-	 */
-	private array $calendarLoaders = [];
-
-	public function __construct(
-		private Coordinator $coordinator,
-		private ContainerInterface $container,
-		private LoggerInterface $logger,
-		private ITimeFactory $timeFactory,
-		private ISecureRandom $random,
-		private IUserManager $userManager,
-		private ServerFactory $serverFactory,
-		private PropertyMapper $propertyMapper,
-	) {
-	}
-
-	/**
-	 * This function is used to search and find objects within the user's calendars.
-	 * In case $pattern is empty all events/journals/todos will be returned.
-	 *
-	 * @param string $pattern which should match within the $searchProperties
-	 * @param array $searchProperties defines the properties within the query pattern should match
-	 * @param array $options - optional parameters:
-	 *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
-	 * @param integer|null $limit - limit number of search results
-	 * @param integer|null $offset - offset for paging of search results
-	 * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
-	 * @since 13.0.0
-	 */
-	public function search(
-		$pattern,
-		array $searchProperties = [],
-		array $options = [],
-		$limit = null,
-		$offset = null,
-	): array {
-		$this->loadCalendars();
-		$result = [];
-		foreach ($this->calendars as $calendar) {
-			$r = $calendar->search($pattern, $searchProperties, $options, $limit, $offset);
-			foreach ($r as $o) {
-				$o['calendar-key'] = $calendar->getKey();
-				$result[] = $o;
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Check if calendars are available
-	 *
-	 * @return bool true if enabled, false if not
-	 * @since 13.0.0
-	 */
-	public function isEnabled(): bool {
-		return !empty($this->calendars) || !empty($this->calendarLoaders);
-	}
-
-	/**
-	 * Registers a calendar
-	 *
-	 * @since 13.0.0
-	 */
-	public function registerCalendar(ICalendar $calendar): void {
-		$this->calendars[$calendar->getKey()] = $calendar;
-	}
-
-	/**
-	 * Unregisters a calendar
-	 *
-	 * @since 13.0.0
-	 */
-	public function unregisterCalendar(ICalendar $calendar): void {
-		unset($this->calendars[$calendar->getKey()]);
-	}
-
-	/**
-	 * In order to improve lazy loading a closure can be registered which will be called in case
-	 * calendars are actually requested
-	 *
-	 * @since 13.0.0
-	 */
-	public function register(\Closure $callable): void {
-		$this->calendarLoaders[] = $callable;
-	}
-
-	/**
-	 * @return ICalendar[]
-	 *
-	 * @since 13.0.0
-	 */
-	public function getCalendars(): array {
-		$this->loadCalendars();
-
-		return array_values($this->calendars);
-	}
-
-	/**
-	 * removes all registered calendar instances
-	 *
-	 * @since 13.0.0
-	 */
-	public function clear(): void {
-		$this->calendars = [];
-		$this->calendarLoaders = [];
-	}
-
-	/**
-	 * loads all calendars
-	 */
-	private function loadCalendars(): void {
-		foreach ($this->calendarLoaders as $callable) {
-			$callable($this);
-		}
-		$this->calendarLoaders = [];
-	}
-
-	/**
-	 * @return ICreateFromString[]
-	 */
-	public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array {
-		$context = $this->coordinator->getRegistrationContext();
-		if ($context === null) {
-			return [];
-		}
-
-		return array_merge(
-			...array_map(function ($registration) use ($principalUri, $calendarUris) {
-				try {
-					/** @var ICalendarProvider $provider */
-					$provider = $this->container->get($registration->getService());
-				} catch (Throwable $e) {
-					$this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
-						'exception' => $e,
-					]);
-					return [];
-				}
-
-				return $provider->getCalendars($principalUri, $calendarUris);
-			}, $context->getCalendarProviders())
-		);
-	}
-
-	public function searchForPrincipal(ICalendarQuery $query): array {
-		/** @var CalendarQuery $query */
-		$calendars = $this->getCalendarsForPrincipal(
-			$query->getPrincipalUri(),
-			$query->getCalendarUris(),
-		);
-
-		$results = [];
-		foreach ($calendars as $calendar) {
-			$r = $calendar->search(
-				$query->getSearchPattern() ?? '',
-				$query->getSearchProperties(),
-				$query->getOptions(),
-				$query->getLimit(),
-				$query->getOffset()
-			);
-
-			foreach ($r as $o) {
-				$o['calendar-key'] = $calendar->getKey();
-				$o['calendar-uri'] = $calendar->getUri();
-				$results[] = $o;
-			}
-		}
-		return $results;
-	}
-
-	public function newQuery(string $principalUri): ICalendarQuery {
-		return new CalendarQuery($principalUri);
-	}
-
-	/**
-	 * @since 32.0.0
-	 *
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMip(
-		string $userId,
-		string $message,
-		array $options = [],
-	): bool {
-
-		$userUri = 'principals/users/' . $userId;
-
-		$userCalendars = $this->getCalendarsForPrincipal($userUri);
-		if (empty($userCalendars)) {
-			$this->logger->warning('iMip message could not be processed because user has no calendars');
-			return false;
-		}
-
-		try {
-			/** @var VCalendar $vObject|null */
-			$vObject = Reader::read($message);
-		} catch (ParseException $e) {
-			$this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
-			return false;
-		}
-
-		if (!isset($vObject->VEVENT)) {
-			$this->logger->warning('iMip message does not contain any event(s)');
-			return false;
-		}
-		/** @var VEvent $vEvent */
-		$vEvent = $vObject->VEVENT;
-
-		if (!isset($vEvent->UID)) {
-			$this->logger->warning('iMip message event dose not contains a UID');
-			return false;
-		}
-
-		if (!isset($vEvent->ORGANIZER)) {
-			$this->logger->warning('iMip message event dose not contains an organizer');
-			return false;
-		}
-
-		if (!isset($vEvent->ATTENDEE)) {
-			$this->logger->warning('iMip message event dose not contains any attendees');
-			return false;
-		}
-
-		foreach ($userCalendars as $calendar) {
-			if (!$calendar instanceof ICalendarIsWritable) {
-				continue;
-			}
-			if ($calendar->isDeleted() || !$calendar->isWritable()) {
-				continue;
-			}
-			if (!empty($calendar->search('', [], ['uid' => $vEvent->UID->getValue()]))) {
-				try {
-					if ($calendar instanceof IHandleImipMessage) {
-						$calendar->handleIMipMessage($userId, $vObject->serialize());
-					}
-					return true;
-				} catch (CalendarException $e) {
-					$this->logger->error('iMip message could not be processed because an error occurred', ['exception' => $e]);
-					return false;
-				}
-			}
-		}
-
-		if ($options['absent'] === 'create') {
-			// retrieve the primary calendar for the user
-			$calendar = $this->getPrimaryCalendar($userId);
-			if ($calendar !== null && (
-				!$calendar instanceof IHandleImipMessage || !$calendar instanceof ICalendarIsWritable || $calendar->isDeleted() || !$calendar->isWritable()
-			)) {
-				$calendar = null;
-			}
-			// if no primary calendar is set, use the first writable calendar
-			if ($calendar === null) {
-				foreach ($userCalendars as $userCalendar) {
-					if ($userCalendar instanceof IHandleImipMessage && $userCalendar instanceof ICalendarIsWritable && !$userCalendar->isDeleted() && $userCalendar->isWritable()) {
-						$calendar = $userCalendar;
-						break;
-					}
-				}
-			}
-			if ($calendar === null) {
-				$this->logger->warning('iMip message could not be processed because no writable calendar was found');
-				return false;
-			}
-			$calendar->handleIMipMessage($userId, $vObject->serialize());
-		}
-
-		$this->logger->warning('iMip message could not be processed because no corresponding event was found in any calendar');
-
-		return false;
-	}
-
-	/**
-	 * @since 31.0.0
-	 *
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipRequest(
-		string $principalUri,
-		string $sender,
-		string $recipient,
-		string $calendarData,
-	): bool {
-		if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
-			$this->logger->error('Invalid principal URI provided for iMip request');
-			return false;
-		}
-		$userId = substr($principalUri, 17);
-		return $this->handleIMip($userId, $calendarData);
-	}
-
-	/**
-	 * @since 25.0.0
-	 *
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipReply(
-		string $principalUri,
-		string $sender,
-		string $recipient,
-		string $calendarData,
-	): bool {
-		if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
-			$this->logger->error('Invalid principal URI provided for iMip reply');
-			return false;
-		}
-		$userId = substr($principalUri, 17);
-		return $this->handleIMip($userId, $calendarData);
-	}
-
-	/**
-	 * @since 25.0.0
-	 *
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipCancel(
-		string $principalUri,
-		string $sender,
-		?string $replyTo,
-		string $recipient,
-		string $calendarData,
-	): bool {
-		if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
-			$this->logger->error('Invalid principal URI provided for iMip cancel');
-			return false;
-		}
-		$userId = substr($principalUri, 17);
-		return $this->handleIMip($userId, $calendarData);
-	}
-
-	public function createEventBuilder(): ICalendarEventBuilder {
-		$uid = $this->random->generate(32, ISecureRandom::CHAR_ALPHANUMERIC);
-		return new CalendarEventBuilder($uid, $this->timeFactory);
-	}
-
-	public function checkAvailability(
-		DateTimeInterface $start,
-		DateTimeInterface $end,
-		IUser $organizer,
-		array $attendees,
-	): array {
-		$organizerMailto = 'mailto:' . $organizer->getEMailAddress();
-		$request = new VCalendar();
-		$request->METHOD = 'REQUEST';
-		$request->add('VFREEBUSY', [
-			'DTSTART' => $start,
-			'DTEND' => $end,
-			'ORGANIZER' => $organizerMailto,
-			'ATTENDEE' => $organizerMailto,
-		]);
-
-		$mailtoLen = strlen('mailto:');
-		foreach ($attendees as $attendee) {
-			if (str_starts_with($attendee, 'mailto:')) {
-				$attendee = substr($attendee, $mailtoLen);
-			}
-
-			$attendeeUsers = $this->userManager->getByEmail($attendee);
-			if ($attendeeUsers === []) {
-				continue;
-			}
-
-			$request->VFREEBUSY->add('ATTENDEE', "mailto:$attendee");
-		}
-
-		$organizerUid = $organizer->getUID();
-		$server = $this->serverFactory->createAttendeeAvailabilityServer();
-		/** @var CustomPrincipalPlugin $plugin */
-		$plugin = $server->getPlugin('auth');
-		$plugin->setCurrentPrincipal("principals/users/$organizerUid");
-
-		$request = new Request(
-			'POST',
-			"/calendars/$organizerUid/outbox/",
-			[
-				'Content-Type' => 'text/calendar',
-				'Depth' => 0,
-			],
-			$request->serialize(),
-		);
-		$response = new Response();
-		$server->invokeMethod($request, $response, false);
-
-		$xmlService = new \Sabre\Xml\Service();
-		$xmlService->elementMap = [
-			'{urn:ietf:params:xml:ns:caldav}response' => 'Sabre\Xml\Deserializer\keyValue',
-			'{urn:ietf:params:xml:ns:caldav}recipient' => 'Sabre\Xml\Deserializer\keyValue',
-		];
-		$parsedResponse = $xmlService->parse($response->getBodyAsString());
-
-		$result = [];
-		foreach ($parsedResponse as $freeBusyResponse) {
-			$freeBusyResponse = $freeBusyResponse['value'];
-			if ($freeBusyResponse['{urn:ietf:params:xml:ns:caldav}request-status'] !== '2.0;Success') {
-				continue;
-			}
-
-			$freeBusyResponseData = \Sabre\VObject\Reader::read(
-				$freeBusyResponse['{urn:ietf:params:xml:ns:caldav}calendar-data']
-			);
-
-			$attendee = substr(
-				$freeBusyResponse['{urn:ietf:params:xml:ns:caldav}recipient']['{DAV:}href'],
-				$mailtoLen,
-			);
-
-			$vFreeBusy = $freeBusyResponseData->VFREEBUSY;
-			if (!($vFreeBusy instanceof VFreeBusy)) {
-				continue;
-			}
-
-			// TODO: actually check values of FREEBUSY properties to find a free slot
-			$result[] = new AvailabilityResult($attendee, $vFreeBusy->isFree($start, $end));
-		}
-
-		return $result;
-	}
-
-	public function getPrimaryCalendar(string $userId): ?ICalendar {
-		// determine if the principal has a default calendar configured
-		$properties = $this->propertyMapper->findPropertyByPathAndName(
-			$userId,
-			'principals/users/' . $userId,
-			'{urn:ietf:params:xml:ns:caldav}schedule-default-calendar-URL'
-		);
-		if ($properties === []) {
-			return null;
-		}
-		// extract the calendar URI from the property value
-		$propertyValue = $properties[0]->getPropertyvalue() ?? null;
-		if (str_starts_with($propertyValue, 'calendars/' . $userId)) {
-			$calendarUri = rtrim(str_replace('calendars/' . $userId . '/', '', $propertyValue), '/');
-		}
-		if (empty($calendarUri)) {
-			return null;
-		}
-		// retrieve the calendar by URI
-		$calendars = $this->getCalendarsForPrincipal('principals/users/' . $userId, [$calendarUri]);
-		if ($calendars === []) {
-			return null;
-		}
-
-		return $calendars[0];
-	}
+    /**
+     * @var ICalendar[] holds all registered calendars
+     */
+    private array $calendars = [];
+
+    /**
+     * @var \Closure[] to call to load/register calendar providers
+     */
+    private array $calendarLoaders = [];
+
+    public function __construct(
+        private Coordinator $coordinator,
+        private ContainerInterface $container,
+        private LoggerInterface $logger,
+        private ITimeFactory $timeFactory,
+        private ISecureRandom $random,
+        private IUserManager $userManager,
+        private ServerFactory $serverFactory,
+        private PropertyMapper $propertyMapper,
+    ) {
+    }
+
+    /**
+     * This function is used to search and find objects within the user's calendars.
+     * In case $pattern is empty all events/journals/todos will be returned.
+     *
+     * @param string $pattern which should match within the $searchProperties
+     * @param array $searchProperties defines the properties within the query pattern should match
+     * @param array $options - optional parameters:
+     *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
+     * @param integer|null $limit - limit number of search results
+     * @param integer|null $offset - offset for paging of search results
+     * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
+     * @since 13.0.0
+     */
+    public function search(
+        $pattern,
+        array $searchProperties = [],
+        array $options = [],
+        $limit = null,
+        $offset = null,
+    ): array {
+        $this->loadCalendars();
+        $result = [];
+        foreach ($this->calendars as $calendar) {
+            $r = $calendar->search($pattern, $searchProperties, $options, $limit, $offset);
+            foreach ($r as $o) {
+                $o['calendar-key'] = $calendar->getKey();
+                $result[] = $o;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Check if calendars are available
+     *
+     * @return bool true if enabled, false if not
+     * @since 13.0.0
+     */
+    public function isEnabled(): bool {
+        return !empty($this->calendars) || !empty($this->calendarLoaders);
+    }
+
+    /**
+     * Registers a calendar
+     *
+     * @since 13.0.0
+     */
+    public function registerCalendar(ICalendar $calendar): void {
+        $this->calendars[$calendar->getKey()] = $calendar;
+    }
+
+    /**
+     * Unregisters a calendar
+     *
+     * @since 13.0.0
+     */
+    public function unregisterCalendar(ICalendar $calendar): void {
+        unset($this->calendars[$calendar->getKey()]);
+    }
+
+    /**
+     * In order to improve lazy loading a closure can be registered which will be called in case
+     * calendars are actually requested
+     *
+     * @since 13.0.0
+     */
+    public function register(\Closure $callable): void {
+        $this->calendarLoaders[] = $callable;
+    }
+
+    /**
+     * @return ICalendar[]
+     *
+     * @since 13.0.0
+     */
+    public function getCalendars(): array {
+        $this->loadCalendars();
+
+        return array_values($this->calendars);
+    }
+
+    /**
+     * removes all registered calendar instances
+     *
+     * @since 13.0.0
+     */
+    public function clear(): void {
+        $this->calendars = [];
+        $this->calendarLoaders = [];
+    }
+
+    /**
+     * loads all calendars
+     */
+    private function loadCalendars(): void {
+        foreach ($this->calendarLoaders as $callable) {
+            $callable($this);
+        }
+        $this->calendarLoaders = [];
+    }
+
+    /**
+     * @return ICreateFromString[]
+     */
+    public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array {
+        $context = $this->coordinator->getRegistrationContext();
+        if ($context === null) {
+            return [];
+        }
+
+        return array_merge(
+            ...array_map(function ($registration) use ($principalUri, $calendarUris) {
+                try {
+                    /** @var ICalendarProvider $provider */
+                    $provider = $this->container->get($registration->getService());
+                } catch (Throwable $e) {
+                    $this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
+                        'exception' => $e,
+                    ]);
+                    return [];
+                }
+
+                return $provider->getCalendars($principalUri, $calendarUris);
+            }, $context->getCalendarProviders())
+        );
+    }
+
+    public function searchForPrincipal(ICalendarQuery $query): array {
+        /** @var CalendarQuery $query */
+        $calendars = $this->getCalendarsForPrincipal(
+            $query->getPrincipalUri(),
+            $query->getCalendarUris(),
+        );
+
+        $results = [];
+        foreach ($calendars as $calendar) {
+            $r = $calendar->search(
+                $query->getSearchPattern() ?? '',
+                $query->getSearchProperties(),
+                $query->getOptions(),
+                $query->getLimit(),
+                $query->getOffset()
+            );
+
+            foreach ($r as $o) {
+                $o['calendar-key'] = $calendar->getKey();
+                $o['calendar-uri'] = $calendar->getUri();
+                $results[] = $o;
+            }
+        }
+        return $results;
+    }
+
+    public function newQuery(string $principalUri): ICalendarQuery {
+        return new CalendarQuery($principalUri);
+    }
+
+    /**
+     * @since 32.0.0
+     *
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMip(
+        string $userId,
+        string $message,
+        array $options = [],
+    ): bool {
+
+        $userUri = 'principals/users/' . $userId;
+
+        $userCalendars = $this->getCalendarsForPrincipal($userUri);
+        if (empty($userCalendars)) {
+            $this->logger->warning('iMip message could not be processed because user has no calendars');
+            return false;
+        }
+
+        try {
+            /** @var VCalendar $vObject|null */
+            $vObject = Reader::read($message);
+        } catch (ParseException $e) {
+            $this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
+            return false;
+        }
+
+        if (!isset($vObject->VEVENT)) {
+            $this->logger->warning('iMip message does not contain any event(s)');
+            return false;
+        }
+        /** @var VEvent $vEvent */
+        $vEvent = $vObject->VEVENT;
+
+        if (!isset($vEvent->UID)) {
+            $this->logger->warning('iMip message event dose not contains a UID');
+            return false;
+        }
+
+        if (!isset($vEvent->ORGANIZER)) {
+            $this->logger->warning('iMip message event dose not contains an organizer');
+            return false;
+        }
+
+        if (!isset($vEvent->ATTENDEE)) {
+            $this->logger->warning('iMip message event dose not contains any attendees');
+            return false;
+        }
+
+        foreach ($userCalendars as $calendar) {
+            if (!$calendar instanceof ICalendarIsWritable) {
+                continue;
+            }
+            if ($calendar->isDeleted() || !$calendar->isWritable()) {
+                continue;
+            }
+            if (!empty($calendar->search('', [], ['uid' => $vEvent->UID->getValue()]))) {
+                try {
+                    if ($calendar instanceof IHandleImipMessage) {
+                        $calendar->handleIMipMessage($userId, $vObject->serialize());
+                    }
+                    return true;
+                } catch (CalendarException $e) {
+                    $this->logger->error('iMip message could not be processed because an error occurred', ['exception' => $e]);
+                    return false;
+                }
+            }
+        }
+
+        if ($options['absent'] === 'create') {
+            // retrieve the primary calendar for the user
+            $calendar = $this->getPrimaryCalendar($userId);
+            if ($calendar !== null && (
+                !$calendar instanceof IHandleImipMessage || !$calendar instanceof ICalendarIsWritable || $calendar->isDeleted() || !$calendar->isWritable()
+            )) {
+                $calendar = null;
+            }
+            // if no primary calendar is set, use the first writable calendar
+            if ($calendar === null) {
+                foreach ($userCalendars as $userCalendar) {
+                    if ($userCalendar instanceof IHandleImipMessage && $userCalendar instanceof ICalendarIsWritable && !$userCalendar->isDeleted() && $userCalendar->isWritable()) {
+                        $calendar = $userCalendar;
+                        break;
+                    }
+                }
+            }
+            if ($calendar === null) {
+                $this->logger->warning('iMip message could not be processed because no writable calendar was found');
+                return false;
+            }
+            $calendar->handleIMipMessage($userId, $vObject->serialize());
+        }
+
+        $this->logger->warning('iMip message could not be processed because no corresponding event was found in any calendar');
+
+        return false;
+    }
+
+    /**
+     * @since 31.0.0
+     *
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipRequest(
+        string $principalUri,
+        string $sender,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+        if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
+            $this->logger->error('Invalid principal URI provided for iMip request');
+            return false;
+        }
+        $userId = substr($principalUri, 17);
+        return $this->handleIMip($userId, $calendarData);
+    }
+
+    /**
+     * @since 25.0.0
+     *
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipReply(
+        string $principalUri,
+        string $sender,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+        if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
+            $this->logger->error('Invalid principal URI provided for iMip reply');
+            return false;
+        }
+        $userId = substr($principalUri, 17);
+        return $this->handleIMip($userId, $calendarData);
+    }
+
+    /**
+     * @since 25.0.0
+     *
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipCancel(
+        string $principalUri,
+        string $sender,
+        ?string $replyTo,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+        if (empty($principalUri) || !str_starts_with($principalUri, 'principals/users/')) {
+            $this->logger->error('Invalid principal URI provided for iMip cancel');
+            return false;
+        }
+        $userId = substr($principalUri, 17);
+        return $this->handleIMip($userId, $calendarData);
+    }
+
+    public function createEventBuilder(): ICalendarEventBuilder {
+        $uid = $this->random->generate(32, ISecureRandom::CHAR_ALPHANUMERIC);
+        return new CalendarEventBuilder($uid, $this->timeFactory);
+    }
+
+    public function checkAvailability(
+        DateTimeInterface $start,
+        DateTimeInterface $end,
+        IUser $organizer,
+        array $attendees,
+    ): array {
+        $organizerMailto = 'mailto:' . $organizer->getEMailAddress();
+        $request = new VCalendar();
+        $request->METHOD = 'REQUEST';
+        $request->add('VFREEBUSY', [
+            'DTSTART' => $start,
+            'DTEND' => $end,
+            'ORGANIZER' => $organizerMailto,
+            'ATTENDEE' => $organizerMailto,
+        ]);
+
+        $mailtoLen = strlen('mailto:');
+        foreach ($attendees as $attendee) {
+            if (str_starts_with($attendee, 'mailto:')) {
+                $attendee = substr($attendee, $mailtoLen);
+            }
+
+            $attendeeUsers = $this->userManager->getByEmail($attendee);
+            if ($attendeeUsers === []) {
+                continue;
+            }
+
+            $request->VFREEBUSY->add('ATTENDEE', "mailto:$attendee");
+        }
+
+        $organizerUid = $organizer->getUID();
+        $server = $this->serverFactory->createAttendeeAvailabilityServer();
+        /** @var CustomPrincipalPlugin $plugin */
+        $plugin = $server->getPlugin('auth');
+        $plugin->setCurrentPrincipal("principals/users/$organizerUid");
+
+        $request = new Request(
+            'POST',
+            "/calendars/$organizerUid/outbox/",
+            [
+                'Content-Type' => 'text/calendar',
+                'Depth' => 0,
+            ],
+            $request->serialize(),
+        );
+        $response = new Response();
+        $server->invokeMethod($request, $response, false);
+
+        $xmlService = new \Sabre\Xml\Service();
+        $xmlService->elementMap = [
+            '{urn:ietf:params:xml:ns:caldav}response' => 'Sabre\Xml\Deserializer\keyValue',
+            '{urn:ietf:params:xml:ns:caldav}recipient' => 'Sabre\Xml\Deserializer\keyValue',
+        ];
+        $parsedResponse = $xmlService->parse($response->getBodyAsString());
+
+        $result = [];
+        foreach ($parsedResponse as $freeBusyResponse) {
+            $freeBusyResponse = $freeBusyResponse['value'];
+            if ($freeBusyResponse['{urn:ietf:params:xml:ns:caldav}request-status'] !== '2.0;Success') {
+                continue;
+            }
+
+            $freeBusyResponseData = \Sabre\VObject\Reader::read(
+                $freeBusyResponse['{urn:ietf:params:xml:ns:caldav}calendar-data']
+            );
+
+            $attendee = substr(
+                $freeBusyResponse['{urn:ietf:params:xml:ns:caldav}recipient']['{DAV:}href'],
+                $mailtoLen,
+            );
+
+            $vFreeBusy = $freeBusyResponseData->VFREEBUSY;
+            if (!($vFreeBusy instanceof VFreeBusy)) {
+                continue;
+            }
+
+            // TODO: actually check values of FREEBUSY properties to find a free slot
+            $result[] = new AvailabilityResult($attendee, $vFreeBusy->isFree($start, $end));
+        }
+
+        return $result;
+    }
+
+    public function getPrimaryCalendar(string $userId): ?ICalendar {
+        // determine if the principal has a default calendar configured
+        $properties = $this->propertyMapper->findPropertyByPathAndName(
+            $userId,
+            'principals/users/' . $userId,
+            '{urn:ietf:params:xml:ns:caldav}schedule-default-calendar-URL'
+        );
+        if ($properties === []) {
+            return null;
+        }
+        // extract the calendar URI from the property value
+        $propertyValue = $properties[0]->getPropertyvalue() ?? null;
+        if (str_starts_with($propertyValue, 'calendars/' . $userId)) {
+            $calendarUri = rtrim(str_replace('calendars/' . $userId . '/', '', $propertyValue), '/');
+        }
+        if (empty($calendarUri)) {
+            return null;
+        }
+        // retrieve the calendar by URI
+        $calendars = $this->getCalendarsForPrincipal('principals/users/' . $userId, [$calendarUri]);
+        if ($calendars === []) {
+            return null;
+        }
+
+        return $calendars[0];
+    }
 
 }

Spacing +8 added lines, -8 removed lines

@@ -175,12 +175,12 @@ 
 		}
 
 		return array_merge(
-			...array_map(function ($registration) use ($principalUri, $calendarUris) {
+			...array_map(function($registration) use ($principalUri, $calendarUris) {
 				try {
 					/** @var ICalendarProvider $provider */
 					$provider = $this->container->get($registration->getService());
 				} catch (Throwable $e) {
-					$this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
+					$this->logger->error('Could not load calendar provider '.$registration->getService().': '.$e->getMessage(), [
 						'exception' => $e,
 					]);
 					return [];
@@ -232,7 +232,7 @@ 
 		array $options = [],
 	): bool {
 
-		$userUri = 'principals/users/' . $userId;
+		$userUri = 'principals/users/'.$userId;
 
 		$userCalendars = $this->getCalendarsForPrincipal($userUri);
 		if (empty($userCalendars)) {
@@ -388,7 +388,7 @@ 
 		IUser $organizer,
 		array $attendees,
 	): array {
-		$organizerMailto = 'mailto:' . $organizer->getEMailAddress();
+		$organizerMailto = 'mailto:'.$organizer->getEMailAddress();
 		$request = new VCalendar();
 		$request->METHOD = 'REQUEST';
 		$request->add('VFREEBUSY', [
@@ -469,7 +469,7 @@ 
 		// determine if the principal has a default calendar configured
 		$properties = $this->propertyMapper->findPropertyByPathAndName(
 			$userId,
-			'principals/users/' . $userId,
+			'principals/users/'.$userId,
 			'{urn:ietf:params:xml:ns:caldav}schedule-default-calendar-URL'
 		);
 		if ($properties === []) {
@@ -477,14 +477,14 @@ 
 		}
 		// extract the calendar URI from the property value
 		$propertyValue = $properties[0]->getPropertyvalue() ?? null;
-		if (str_starts_with($propertyValue, 'calendars/' . $userId)) {
-			$calendarUri = rtrim(str_replace('calendars/' . $userId . '/', '', $propertyValue), '/');
+		if (str_starts_with($propertyValue, 'calendars/'.$userId)) {
+			$calendarUri = rtrim(str_replace('calendars/'.$userId.'/', '', $propertyValue), '/');
 		}
 		if (empty($calendarUri)) {
 			return null;
 		}
 		// retrieve the calendar by URI
-		$calendars = $this->getCalendarsForPrincipal('principals/users/' . $userId, [$calendarUri]);
+		$calendars = $this->getCalendarsForPrincipal('principals/users/'.$userId, [$calendarUri]);
 		if ($calendars === []) {
 			return null;
 		}

lib/public/Calendar/IManager.php

Indentation +153 added lines, -153 removed lines

@@ -42,157 +42,157 @@
  * @since 13.0.0
  */
 interface IManager {
-	/**
-	 * This function is used to search and find objects within the user's calendars.
-	 * In case $pattern is empty all events/journals/todos will be returned.
-	 *
-	 * @param string $pattern which should match within the $searchProperties
-	 * @param array $searchProperties defines the properties within the query pattern should match
-	 * @param array $options - optional parameters:
-	 *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
-	 * @param integer|null $limit - limit number of search results
-	 * @param integer|null $offset - offset for paging of search results
-	 * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
-	 * @since 13.0.0
-	 * @deprecated 23.0.0 use \OCP\Calendar\IManager::searchForPrincipal
-	 */
-	public function search($pattern, array $searchProperties = [], array $options = [], $limit = null, $offset = null);
-
-	/**
-	 * Check if calendars are available
-	 *
-	 * @return bool true if enabled, false if not
-	 * @since 13.0.0
-	 * @deprecated 23.0.0
-	 */
-	public function isEnabled();
-
-	/**
-	 * Registers a calendar
-	 *
-	 * @param ICalendar $calendar
-	 * @return void
-	 * @since 13.0.0
-	 * @deprecated 23.0.0 use \OCP\AppFramework\Bootstrap\IRegistrationContext::registerCalendarProvider
-	 */
-	public function registerCalendar(ICalendar $calendar);
-
-	/**
-	 * Unregisters a calendar
-	 *
-	 * @param ICalendar $calendar
-	 * @return void
-	 * @since 13.0.0
-	 * @deprecated 23.0.0
-	 */
-	public function unregisterCalendar(ICalendar $calendar);
-
-	/**
-	 * In order to improve lazy loading a closure can be registered which will be called in case
-	 * calendars are actually requested
-	 *
-	 * @param \Closure $callable
-	 * @return void
-	 * @since 13.0.0
-	 * @deprecated 23.0.0 use \OCP\AppFramework\Bootstrap\IRegistrationContext::registerCalendarProvider
-	 */
-	public function register(\Closure $callable);
-
-	/**
-	 * @return ICalendar[]
-	 * @since 13.0.0
-	 * @deprecated 23.0.0 use \OCP\Calendar\IManager::getCalendarsForPrincipal
-	 */
-	public function getCalendars();
-
-	/**
-	 * removes all registered calendar instances
-	 *
-	 * @return void
-	 * @since 13.0.0
-	 * @deprecated 23.0.0
-	 */
-	public function clear();
-
-	/**
-	 * @param string $principalUri URI of the principal
-	 * @param string[] $calendarUris optionally specify which calendars to load, or all if this array is empty
-	 *
-	 * @return ICalendar[]
-	 * @since 23.0.0
-	 */
-	public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array;
-
-	/**
-	 * Query a principals calendar(s)
-	 *
-	 * @param ICalendarQuery $query
-	 * @return array[]
-	 * @since 23.0.0
-	 */
-	public function searchForPrincipal(ICalendarQuery $query): array;
-
-	/**
-	 * Build a new query for searchForPrincipal
-	 *
-	 * @return ICalendarQuery
-	 * @since 23.0.0
-	 */
-	public function newQuery(string $principalUri) : ICalendarQuery;
-
-	/**
-	 * Handles a iMip message
-	 *
-	 * @param array{absent?: "create"} $options
-	 *
-	 * @throws \OCP\DB\Exception
-	 *
-	 * @since 32.0.0
-	 */
-	public function handleIMip(string $userId, string $message, array $options = []): bool;
-
-	/**
-	 * Handle a iMip REQUEST message
-	 *
-	 * @since 31.0.0
-	 */
-	public function handleIMipRequest(string $principalUri, string $sender, string $recipient, string $calendarData): bool;
-
-	/**
-	 * Handle a iMip REPLY message
-	 *
-	 * @since 25.0.0
-	 */
-	public function handleIMipReply(string $principalUri, string $sender, string $recipient, string $calendarData): bool;
-
-	/**
-	 * Handle a iMip CANCEL message
-	 *
-	 * @since 25.0.0
-	 */
-	public function handleIMipCancel(string $principalUri, string $sender, ?string $replyTo, string $recipient, string $calendarData): bool;
-
-	/**
-	 * Create a new event builder instance. Please have a look at its documentation and the
-	 * \OCP\Calendar\ICreateFromString interface on how to use it.
-	 *
-	 * @since 31.0.0
-	 */
-	public function createEventBuilder(): ICalendarEventBuilder;
-
-	/**
-	 * Check the availability of the given organizer and attendees in the given time range.
-	 *
-	 * @since 31.0.0
-	 *
-	 * @param IUser $organizer The organizing user from whose perspective to do the availability check.
-	 * @param string[] $attendees Email addresses of attendees to check for (with or without a "mailto:" prefix). Only users on this instance can be checked. The rest will be silently ignored.
-	 * @return IAvailabilityResult[] Availabilities of the organizer and all attendees which are also users on this instance. As such, the array might not contain an entry for each given attendee.
-	 */
-	public function checkAvailability(
-		DateTimeInterface $start,
-		DateTimeInterface $end,
-		IUser $organizer,
-		array $attendees,
-	): array;
+    /**
+     * This function is used to search and find objects within the user's calendars.
+     * In case $pattern is empty all events/journals/todos will be returned.
+     *
+     * @param string $pattern which should match within the $searchProperties
+     * @param array $searchProperties defines the properties within the query pattern should match
+     * @param array $options - optional parameters:
+     *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
+     * @param integer|null $limit - limit number of search results
+     * @param integer|null $offset - offset for paging of search results
+     * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
+     * @since 13.0.0
+     * @deprecated 23.0.0 use \OCP\Calendar\IManager::searchForPrincipal
+     */
+    public function search($pattern, array $searchProperties = [], array $options = [], $limit = null, $offset = null);
+
+    /**
+     * Check if calendars are available
+     *
+     * @return bool true if enabled, false if not
+     * @since 13.0.0
+     * @deprecated 23.0.0
+     */
+    public function isEnabled();
+
+    /**
+     * Registers a calendar
+     *
+     * @param ICalendar $calendar
+     * @return void
+     * @since 13.0.0
+     * @deprecated 23.0.0 use \OCP\AppFramework\Bootstrap\IRegistrationContext::registerCalendarProvider
+     */
+    public function registerCalendar(ICalendar $calendar);
+
+    /**
+     * Unregisters a calendar
+     *
+     * @param ICalendar $calendar
+     * @return void
+     * @since 13.0.0
+     * @deprecated 23.0.0
+     */
+    public function unregisterCalendar(ICalendar $calendar);
+
+    /**
+     * In order to improve lazy loading a closure can be registered which will be called in case
+     * calendars are actually requested
+     *
+     * @param \Closure $callable
+     * @return void
+     * @since 13.0.0
+     * @deprecated 23.0.0 use \OCP\AppFramework\Bootstrap\IRegistrationContext::registerCalendarProvider
+     */
+    public function register(\Closure $callable);
+
+    /**
+     * @return ICalendar[]
+     * @since 13.0.0
+     * @deprecated 23.0.0 use \OCP\Calendar\IManager::getCalendarsForPrincipal
+     */
+    public function getCalendars();
+
+    /**
+     * removes all registered calendar instances
+     *
+     * @return void
+     * @since 13.0.0
+     * @deprecated 23.0.0
+     */
+    public function clear();
+
+    /**
+     * @param string $principalUri URI of the principal
+     * @param string[] $calendarUris optionally specify which calendars to load, or all if this array is empty
+     *
+     * @return ICalendar[]
+     * @since 23.0.0
+     */
+    public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array;
+
+    /**
+     * Query a principals calendar(s)
+     *
+     * @param ICalendarQuery $query
+     * @return array[]
+     * @since 23.0.0
+     */
+    public function searchForPrincipal(ICalendarQuery $query): array;
+
+    /**
+     * Build a new query for searchForPrincipal
+     *
+     * @return ICalendarQuery
+     * @since 23.0.0
+     */
+    public function newQuery(string $principalUri) : ICalendarQuery;
+
+    /**
+     * Handles a iMip message
+     *
+     * @param array{absent?: "create"} $options
+     *
+     * @throws \OCP\DB\Exception
+     *
+     * @since 32.0.0
+     */
+    public function handleIMip(string $userId, string $message, array $options = []): bool;
+
+    /**
+     * Handle a iMip REQUEST message
+     *
+     * @since 31.0.0
+     */
+    public function handleIMipRequest(string $principalUri, string $sender, string $recipient, string $calendarData): bool;
+
+    /**
+     * Handle a iMip REPLY message
+     *
+     * @since 25.0.0
+     */
+    public function handleIMipReply(string $principalUri, string $sender, string $recipient, string $calendarData): bool;
+
+    /**
+     * Handle a iMip CANCEL message
+     *
+     * @since 25.0.0
+     */
+    public function handleIMipCancel(string $principalUri, string $sender, ?string $replyTo, string $recipient, string $calendarData): bool;
+
+    /**
+     * Create a new event builder instance. Please have a look at its documentation and the
+     * \OCP\Calendar\ICreateFromString interface on how to use it.
+     *
+     * @since 31.0.0
+     */
+    public function createEventBuilder(): ICalendarEventBuilder;
+
+    /**
+     * Check the availability of the given organizer and attendees in the given time range.
+     *
+     * @since 31.0.0
+     *
+     * @param IUser $organizer The organizing user from whose perspective to do the availability check.
+     * @param string[] $attendees Email addresses of attendees to check for (with or without a "mailto:" prefix). Only users on this instance can be checked. The rest will be silently ignored.
+     * @return IAvailabilityResult[] Availabilities of the organizer and all attendees which are also users on this instance. As such, the array might not contain an entry for each given attendee.
+     */
+    public function checkAvailability(
+        DateTimeInterface $start,
+        DateTimeInterface $end,
+        IUser $organizer,
+        array $attendees,
+    ): array;
 }