mirror of
https://github.com/inverse-inc/sogo.git
synced 2026-11-20 14:36:53 +00:00
When an organizer saves a recurring event from a CalDAV client and the save changes several occurrences, SOGo sends only one of those changes to the attendees. The other changes are stored in the organizer's calendar, but the attendees never receive them and no error is reported. Which change is sent depends on the order of the occurrences in the request. Send every change instead: first the removed occurrences, then the added or changed occurrences, and last the main event if it changed. The main event goes last because attendees then receive the whole series, which must already include the updated occurrences. The checks on the organizer and on delegated senders are unchanged. Reported to Alinto support as ticket 6099.
1087 lines
48 KiB
JavaScript
1087 lines
48 KiB
JavaScript
import config from '../lib/config'
|
|
import WebDAV from '../lib/WebDAV'
|
|
import TestUtility from '../lib/utilities'
|
|
import ICAL from 'ical.js'
|
|
|
|
beforeAll(function () {
|
|
jasmine.DEFAULT_TIMEOUT_INTERVAL = config.timeout || 10000;
|
|
});
|
|
|
|
describe('CalDAV Scheduling', function() {
|
|
const webdav = new WebDAV(config.username, config.password)
|
|
const webdav_su = new WebDAV(config.superuser, config.superuser_password)
|
|
const webdavAttendee1 = new WebDAV(config.attendee1_username, config.attendee1_password)
|
|
const webdavAttendee1Delegate = new WebDAV(config.attendee1_delegate_username, config.attendee1_delegate_password)
|
|
|
|
const utility = new TestUtility(webdav)
|
|
|
|
const userCalendar = `/SOGo/dav/${config.username}/Calendar/personal/`
|
|
const attendee1Calendar = `/SOGo/dav/${config.attendee1_username}/Calendar/personal/`
|
|
const attendee1DelegateCalendar = `/SOGo/dav/${config.attendee1_delegate_username}/Calendar/personal/`
|
|
const resourceNoOverbookCalendar = `/SOGo/dav/${config.resource_no_overbook}/Calendar/personal/`
|
|
const resourceCanOverbookCalendar = `/SOGo/dav/${config.resource_can_overbook}/Calendar/personal/`
|
|
|
|
let user
|
|
let attendee1
|
|
let attendee1Delegate
|
|
let resourceNoOverbook
|
|
let resourceCanOverbook
|
|
|
|
let icsList = []
|
|
|
|
const _getEvent = async function(client, calendarName, filename, expectedCode = 200) {
|
|
const [{ status, raw }] = await client.getObject(calendarName, filename)
|
|
expect(status).toBe(expectedCode)
|
|
if (status <= 300)
|
|
return new ICAL.Component(ICAL.parse(raw))
|
|
}
|
|
|
|
const _getAllEvents = async function(client, calendarName, expectedCode = 207) {
|
|
const results = await client.propfindCollection(calendarName)
|
|
const hrefs = results.filter(r => r.href).map(r => r.href)
|
|
|
|
return hrefs
|
|
}
|
|
|
|
const _putEvent = async function(client, calendarName, filename, event, expectedCode = 201) {
|
|
const response = await client.createCalendarObject(calendarName, filename, event.toString())
|
|
expect(response.status)
|
|
.withContext(`Event creation returns code ${expectedCode}`)
|
|
.toBe(expectedCode)
|
|
return response
|
|
}
|
|
|
|
const _postEvent = async function(client, outbox, vcalendar, originator, recipients, expectedCode = 200) {
|
|
const response = await client.postCaldav(outbox, vcalendar, originator, recipients)
|
|
expect(response.status)
|
|
.withContext(`Event post returns code ${expectedCode}`)
|
|
.toBe(expectedCode)
|
|
return response
|
|
}
|
|
|
|
const _deleteEvent = async function(client, url, expectedCode) {
|
|
const response = await client.deleteObject(url)
|
|
if (expectedCode)
|
|
expect(response.status).toBe(expectedCode)
|
|
return response
|
|
}
|
|
|
|
const _deleteAllEvents = async function(client, calendarName, expectedCode = 204) {
|
|
const hrefs = await _getAllEvents(client, calendarName)
|
|
for (const href of hrefs) {
|
|
await _deleteEvent(client, href) // ignore returned code
|
|
}
|
|
return hrefs
|
|
}
|
|
|
|
const _compareAttendees = function(vcalendar1, vcalendar2) {
|
|
const vevent1 = vcalendar1.getFirstSubcomponent('vevent')
|
|
const vevent2 = vcalendar2.getFirstSubcomponent('vevent')
|
|
const attendeeToString = function(a) {
|
|
const email = a.getFirstValue()
|
|
const partstat = a.getParameter('partstat')
|
|
const delegatedto = a.getParameter('delegated-to') || '(none)'
|
|
const delegatedfrom = a.getParameter('delegated-from') || '(none)'
|
|
return `${email}/${partstat}/${delegatedto}/${delegatedfrom}`
|
|
}
|
|
const attendees1 = vevent1.getAllProperties('attendee').map(attendeeToString)
|
|
const attendees2 = vevent2.getAllProperties('attendee').map(attendeeToString)
|
|
|
|
expect(attendees1.length)
|
|
.withContext(`'vcalendar1' has attendees`)
|
|
.toBeGreaterThan(0)
|
|
expect(attendees2.length)
|
|
.withContext(`'vcalendar2' has attendees`)
|
|
.toBeGreaterThan(0)
|
|
expect(attendees1.length)
|
|
.withContext(`'vcalendar1' and 'vcalendar2' have the same number of attendees`)
|
|
.toBe(attendees2.length)
|
|
|
|
for (let attendee of attendees1) {
|
|
expect(attendees2.indexOf(attendee))
|
|
.withContext(`${attendee} from 'vcalendar1' is found in 'vcalendar2`)
|
|
.toBeGreaterThanOrEqual(0)
|
|
}
|
|
}
|
|
|
|
beforeAll(async function() {
|
|
user = await utility.fetchUserInfo(config.username)
|
|
attendee1 = await utility.fetchUserInfo(config.attendee1_username)
|
|
attendee1Delegate = await utility.fetchUserInfo(config.attendee1_delegate_username)
|
|
resourceNoOverbook = await utility.fetchUserInfo(config.resource_no_overbook)
|
|
resourceCanOverbook = await utility.fetchUserInfo(config.resource_can_overbook)
|
|
|
|
// fetch non existing event to let sogo create the calendars in the db
|
|
await _getEvent(webdav, userCalendar, 'nonexistent', 404)
|
|
await _getEvent(webdavAttendee1, attendee1Calendar, 'nonexistent', 404)
|
|
await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, 'nonexistent', 404)
|
|
})
|
|
|
|
afterEach(async function() {
|
|
for (const ics of icsList) {
|
|
await _deleteEvent(webdav_su, userCalendar + ics)
|
|
await _deleteEvent(webdav_su, attendee1Calendar + ics)
|
|
await _deleteEvent(webdav_su, attendee1DelegateCalendar + ics)
|
|
await _deleteEvent(webdav_su, resourceCanOverbookCalendar + ics)
|
|
await _deleteEvent(webdav_su, resourceNoOverbookCalendar + ics)
|
|
}
|
|
})
|
|
|
|
// CalDAVSchedulingTest
|
|
|
|
it('add attendee after event creation', async function() {
|
|
const icsName = 'test-add-attendee.ics'
|
|
icsList.push(icsName)
|
|
|
|
let vcalendar, vcalendarAttendee
|
|
let vevent, veventAttendee, organizer, attendee
|
|
|
|
// make sure the event doesn't exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdavAttendee1, attendee1Calendar + icsName)
|
|
|
|
// 1. create an event in the organizer's calendar
|
|
vcalendar = utility.createCalendar('Test add attendee', 'Test add attendee')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. add an attendee
|
|
vcalendar.addPropertyWithValue('method', 'REQUEST')
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
vevent.addProperty(attendee)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar, 204)
|
|
|
|
// 3. verify that the attendee has the event
|
|
vcalendarAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
|
|
// 4. make sure the received event match the original one
|
|
veventAttendee = vcalendarAttendee.getFirstSubcomponent('vevent')
|
|
expect(veventAttendee.getFirstProperty('uid').getFirstValue())
|
|
.withContext(`UID in organizer's calendar and attendees's calendar are identical`)
|
|
.toBe(vevent.getFirstProperty('uid').getFirstValue())
|
|
})
|
|
|
|
it('Remove attendee after event creation', async function() {
|
|
const icsName = 'test-remove-attendee.ics'
|
|
icsList.push(icsName)
|
|
|
|
let vcalendar, vcalendarNoAttendee, vcalendarAttendee
|
|
let vevent, veventAttendee, organizer, attendee
|
|
|
|
// make sure the event doesn't exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdavAttendee1, attendee1Calendar + icsName)
|
|
|
|
// 1. create an event in the organizer's calendar
|
|
vcalendar = utility.createCalendar('Test uninvite attendee', 'Test uninvite attendee')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// keep a copy around for updates without other attributes
|
|
vcalendarNoAttendee = ICAL.Component.fromString(vcalendar.toString())
|
|
|
|
// 2. add an attendee
|
|
vcalendar.addPropertyWithValue('method', 'REQUEST')
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
vevent.addProperty(attendee)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar, 204)
|
|
|
|
// 3. verify that the attendee has the event
|
|
vcalendarAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
|
|
// 4. make sure the received event match the original one
|
|
veventAttendee = vcalendarAttendee.getFirstSubcomponent('vevent')
|
|
expect(veventAttendee.getFirstProperty('uid').getFirstValue())
|
|
.toBe(vevent.getFirstProperty('uid').getFirstValue())
|
|
|
|
// 5. uninvite the attendee - put the event back without the attendee
|
|
vevent = vcalendarNoAttendee.getFirstSubcomponent('vevent')
|
|
vevent.addProperty(utility.createDateTimeProperty('last-modified'))
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarNoAttendee, 204)
|
|
|
|
// 6. verify that the attendee doesn't have the event anymore
|
|
await _getEvent(webdavAttendee1, attendee1Calendar, icsName, 404)
|
|
})
|
|
|
|
it('try to overbook a resource', async function() {
|
|
const icsName = 'test-no-overbook.ics'
|
|
const obIcsName = 'test-no-overbook-overlap.ics'
|
|
icsList.push(icsName, obIcsName)
|
|
|
|
let vcalendar, vevent, organizer, attendee
|
|
|
|
// make sure there are no events in the resource calendar
|
|
await _deleteAllEvents(webdav_su, resourceNoOverbookCalendar)
|
|
|
|
// make sure the events don't exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdav, userCalendar + obIcsName)
|
|
|
|
// 1. create an event in the organizer's calendar
|
|
vcalendar = utility.createCalendar('Test no overbook', 'Test no overbook')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceNoOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceNoOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. create a second event overlapping the first one
|
|
vcalendar = utility.createCalendar('Test no overbook - overlap', 'Test no overbook - overlap')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceNoOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceNoOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
// put the event - should trigger a 409
|
|
await _putEvent(webdav, userCalendar, obIcsName, vcalendar, 409)
|
|
})
|
|
|
|
it('try to overbook a resource - multiplebookings=0', async function() {
|
|
const icsName = 'test-can-overbook.ics'
|
|
const obIcsName = 'test-can-overbook-overlap.ics'
|
|
icsList.push(icsName, obIcsName)
|
|
|
|
let vcalendar, vevent, organizer, attendee
|
|
|
|
// make sure there are no events in the resource calendar
|
|
await _deleteAllEvents(webdav_su, resourceCanOverbookCalendar)
|
|
|
|
// make sure the events don't exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdav, userCalendar + obIcsName)
|
|
|
|
// 1. create an event in the organizer's calendar
|
|
vcalendar = utility.createCalendar('Test can overbook', 'Test can overbook')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceCanOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceCanOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. create a second event overlapping the first one
|
|
vcalendar = utility.createCalendar('Test can overbook - overlap', 'Test can overbook - overlap')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceCanOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceCanOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
// put the event - should be fine since we can overbook this one
|
|
await _putEvent(webdav, userCalendar, obIcsName, vcalendar)
|
|
})
|
|
|
|
it('Resource booking overlap detection - bug #1837', async function() {
|
|
// There used to be some problems with recurring events and resources booking
|
|
// This test implements these edge cases
|
|
|
|
// 1. Create recurring event (with resource)
|
|
// 2. Create single event overlaping one instance for the previous event
|
|
// (should fail)
|
|
// 3. Create recurring event which _doesn't_ overlap the first event
|
|
// (should be OK, used to fail pre1.3.17)
|
|
// 4. Create recurring event overlapping the previous recurring event
|
|
// (should fail)
|
|
|
|
const icsName = 'test-res-overlap-detection.ics'
|
|
const overlapIcsName = 'test-res-overlap-detection-overlap.ics'
|
|
icsList.push(icsName, overlapIcsName)
|
|
|
|
let vcalendar, vcalendarNoOverlap
|
|
let vevent, organizer, attendee, rrule, recur, nstartdate, nenddate
|
|
|
|
// make sure there are no events in the resource calendar
|
|
await _deleteAllEvents(webdav_su, resourceNoOverbookCalendar)
|
|
|
|
// make sure the event doesn't exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdav, attendee1Calendar + overlapIcsName)
|
|
|
|
const noOverlapRecurringIcsName = 'test-res-overlap-detection-nooverlap.ics'
|
|
icsList.push(noOverlapRecurringIcsName)
|
|
await _deleteEvent(webdav, userCalendar + noOverlapRecurringIcsName)
|
|
|
|
const overlapRecurringIcsName = 'test-res-overlap-detection-overlap-recurring.ics'
|
|
icsList.push(overlapRecurringIcsName)
|
|
await _deleteEvent(webdav, userCalendar + overlapRecurringIcsName)
|
|
|
|
// 1. create recurring event with resource
|
|
vcalendar = utility.createCalendar('Recurring event with resource', 'Recurring event with resource')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
rrule = new ICAL.Property('rrule')
|
|
recur = new ICAL.Recur({ freq: 'DAILY', count: 5 })
|
|
rrule.setValue(recur)
|
|
vevent.addProperty(rrule)
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceNoOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceNoOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
// keep a copy around for #3
|
|
vcalendarNoOverlap = ICAL.Component.fromString(vcalendar.toString())
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. Create single event overlaping one instance for the previous event
|
|
vcalendar = utility.createCalendar('Recurring event with resource - overlap', 'Recurring event with resource - overlap')
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', attendee1.displayname)
|
|
organizer.setValue(attendee1.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', resourceNoOverbook.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(resourceNoOverbook.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
// should fail
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, overlapIcsName, vcalendar, 409)
|
|
|
|
// 3. Create recurring event which _doesn't_ overlap the first event
|
|
// (should be OK, used to fail pre1.3.17)
|
|
// shift the start date to one hour after the original event end time
|
|
vevent = vcalendarNoOverlap.getFirstSubcomponent('vevent')
|
|
nstartdate = vevent.getFirstProperty('dtend').getFirstValue().toJSDate()
|
|
nstartdate = new Date(nstartdate.getTime() + 1000*60*60)
|
|
nenddate = new Date(nstartdate.getTime() + 1000*60*60)
|
|
vevent.removeProperty('dtstart')
|
|
vevent.removeProperty('dtend')
|
|
vevent.addProperty(utility.createDateTimeProperty('dtstart', nstartdate))
|
|
vevent.addProperty(utility.createDateTimeProperty('dtend', nenddate))
|
|
vevent.updatePropertyWithValue('uid', 'recurring - nooverlap')
|
|
await _putEvent(webdav, userCalendar, noOverlapRecurringIcsName, vcalendarNoOverlap)
|
|
|
|
// 4. Create recurring event overlapping the previous recurring event
|
|
// should fail with a 409
|
|
nstartdate = vevent.getFirstProperty('dtstart').getFirstValue().toJSDate()
|
|
nstartdate = new Date(nstartdate.getTime() + 1000*60*5)
|
|
nenddate = new Date(nstartdate.getTime() + 1000*60*60)
|
|
vevent.removeProperty('dtstart')
|
|
vevent.removeProperty('dtend')
|
|
vevent.addProperty(utility.createDateTimeProperty('dtstart', nstartdate))
|
|
vevent.addProperty(utility.createDateTimeProperty('dtend', nenddate))
|
|
vevent.updatePropertyWithValue('uid', 'recurring - nooverlap')
|
|
await _putEvent(webdav, userCalendar, overlapRecurringIcsName, vcalendarNoOverlap, 409)
|
|
})
|
|
|
|
it('RRULE exception invitation dance', async function() {
|
|
// This workflow is based on what lightning 1.2.1 does
|
|
// create a reccurring event
|
|
// add an exception
|
|
// invite bob to the exception:
|
|
// bob is declined in the master event
|
|
// bob needs-action in the exception
|
|
// bob accepts
|
|
// bob is declined in the master event
|
|
// bob is accepted in the exception
|
|
// the organizer 'uninvites' bob
|
|
// the event disappears from bob's calendar
|
|
// bob isn't in the master+exception event
|
|
|
|
const icsName = 'test-rrule-exception-invitation-dance.ics'
|
|
icsList.push(icsName)
|
|
|
|
let vcalendar, vcalendarOrganizer, vcalendarAttendee, vevents, vevent, veventMaster, veventException
|
|
let recurrenceId, summary, uid, organizer, attendees, attendee, rrule, recur, originalStartDate
|
|
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdav, attendee1Calendar + icsName)
|
|
|
|
// 1. create a recurring event in the organizer's calendar
|
|
summary = 'Test reccuring exception invite cancel'
|
|
uid = 'Test-recurring-exception-invite-cancel'
|
|
vcalendar = utility.createCalendar(summary, uid)
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
rrule = new ICAL.Property('rrule')
|
|
recur = new ICAL.Recur({ freq: 'DAILY', count: 5 })
|
|
rrule.setValue(recur)
|
|
vevent.addProperty(rrule)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// read the event back from the server
|
|
vcalendarOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
|
|
// 2. Add an exception to the master event and invite attendee1 to it
|
|
vevent = vcalendarOrganizer.getFirstSubcomponent('vevent')
|
|
vevent.removeProperty('last-modified')
|
|
vevent.addProperty(utility.createDateTimeProperty('last-modified'))
|
|
originalStartDate = vevent.getFirstPropertyValue('dtstart')
|
|
|
|
veventException = new ICAL.Component('vevent')
|
|
veventException.addProperty(utility.createDateTimeProperty('created'))
|
|
veventException.addProperty(utility.createDateTimeProperty('last-modified'))
|
|
veventException.addProperty(utility.createDateTimeProperty('dtstamp'))
|
|
veventException.addPropertyWithValue('uid', uid)
|
|
veventException.addPropertyWithValue('summary', summary)
|
|
veventException.addPropertyWithValue('transp', 'OPAQUE')
|
|
veventException.addPropertyWithValue('description', 'Exception')
|
|
veventException.addPropertyWithValue('sequence', '1')
|
|
veventException.addProperty(ICAL.Property.fromString(vevent.getFirstProperty('dtstart').toICALString()))
|
|
veventException.addProperty(ICAL.Property.fromString(vevent.getFirstProperty('dtend').toICALString()))
|
|
// out of laziness, add the exception for the first occurence of the event
|
|
recurrenceId = new ICAL.Property('recurrence-id')
|
|
recurrenceId.setParameter('tzid', originalStartDate.timezone)
|
|
recurrenceId.setValue(originalStartDate)
|
|
veventException.addProperty(recurrenceId)
|
|
|
|
// 2.1 Add attendee1 and organizer to the exception
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setParameter('partstat', 'ACCEPTED')
|
|
organizer.setValue(user.email)
|
|
veventException.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('role', 'REQ-PARTICIPANT')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
veventException.addProperty(attendee)
|
|
vcalendarOrganizer.addSubcomponent(veventException)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarOrganizer, 204)
|
|
|
|
// 3. Make sure the attendee got the event
|
|
vcalendarAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
vevents = vcalendarAttendee.getAllSubcomponents('vevent')
|
|
expect(vevents.length)
|
|
.withContext('vEvents count in the calendar of the attendee')
|
|
.toBe(1)
|
|
vevent = vevents[0]
|
|
expect(vevent.getFirstPropertyValue('recurrence-id'))
|
|
.withContext(`The vEvent of the attendee has a RECURRENCE-ID`)
|
|
.toBeTruthy()
|
|
attendees = vevent.getAllProperties('attendee')
|
|
expect(attendees.length)
|
|
.withContext('Attendees count in the calendar of the attendee')
|
|
.toBe(1)
|
|
attendee = attendees[0]
|
|
expect(attendee.getParameter('partstat'))
|
|
.withContext('Partstat of attendee in calendar of the attendee')
|
|
.toBe('NEEDS-ACTION')
|
|
|
|
// 4. attendee accepts invitation
|
|
attendee.setParameter('partstat', 'ACCEPTED')
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, icsName, vcalendarAttendee, 204)
|
|
|
|
// fetch the organizer's event
|
|
vcalendarOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
vevents = vcalendarOrganizer.getAllSubcomponents('vevent')
|
|
expect(vevents.length)
|
|
.withContext('vEvents count in the calendar of the organizer')
|
|
.toBe(2)
|
|
for (vevent of vevents) {
|
|
if (vevent.getFirstPropertyValue('recurrence-id')) {
|
|
veventException = vevent
|
|
} else {
|
|
veventMaster = vevent
|
|
}
|
|
}
|
|
|
|
// make sure sogo doesn't duplicate attendees
|
|
expect(veventMaster.getAllProperties('attendee').length).toBe(0)
|
|
expect(veventException.getAllProperties('attendee').length).toBe(1)
|
|
|
|
// 5. Make sure organizer got the accept for the exception and
|
|
// that the attendee is still declined in the master
|
|
attendee = veventException.getAllProperties('attendee')[0]
|
|
expect(attendee.getParameter('partstat'))
|
|
.withContext('Partstat of attendee in the calendar of the organizer')
|
|
.toBe('ACCEPTED')
|
|
|
|
// 6. delete the attendee from the organizer event (uninvite)
|
|
// The event should be deleted from the attendee's calendar
|
|
vcalendarOrganizer.removeSubcomponent(veventException)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarOrganizer, 204)
|
|
await _getEvent(webdavAttendee1, attendee1Calendar, icsName, 404)
|
|
})
|
|
|
|
describe('RRULE with several changed components in one PUT', function() {
|
|
const _master = function(uid, summary) {
|
|
return [
|
|
'BEGIN:VEVENT',
|
|
`UID:${uid}`,
|
|
'DTSTAMP:20260901T100000Z',
|
|
'DTSTART:20261001T130000Z',
|
|
'DTEND:20261001T140000Z',
|
|
'SEQUENCE:0',
|
|
`SUMMARY:${summary}`,
|
|
'RRULE:FREQ=WEEKLY;COUNT=5',
|
|
`ORGANIZER:${user.email}`,
|
|
`ATTENDEE;RSVP=TRUE;PARTSTAT=NEEDS-ACTION:${attendee1.email}`,
|
|
'END:VEVENT'
|
|
]
|
|
}
|
|
|
|
// Moves the occurrence of 'day' (October 2026) two hours earlier
|
|
const _exception = function(uid, day, partstat) {
|
|
return [
|
|
'BEGIN:VEVENT',
|
|
`UID:${uid}`,
|
|
'DTSTAMP:20260901T100000Z',
|
|
`RECURRENCE-ID:202610${day}T130000Z`,
|
|
`DTSTART:202610${day}T110000Z`,
|
|
`DTEND:202610${day}T120000Z`,
|
|
'SEQUENCE:1',
|
|
'SUMMARY:Weekly sync',
|
|
`ORGANIZER:${user.email}`,
|
|
`ATTENDEE;RSVP=TRUE;PARTSTAT=${partstat}:${attendee1.email}`,
|
|
'END:VEVENT'
|
|
]
|
|
}
|
|
|
|
const _calendar = function(...vevents) {
|
|
const lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//SOGo//Tests//EN']
|
|
return ICAL.Component.fromString(lines.concat(...vevents, 'END:VCALENDAR').join('\r\n'))
|
|
}
|
|
|
|
const _attendeeStartOf = async function(icsName, day) {
|
|
const vcalendar = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
const vevent = vcalendar.getAllSubcomponents('vevent').find(e => {
|
|
const rid = e.getFirstPropertyValue('recurrence-id')
|
|
return day ? rid && rid.toICALString() == `202610${day}T130000Z` : !rid
|
|
})
|
|
return vevent && vevent.getFirstPropertyValue('dtstart').toICALString()
|
|
}
|
|
|
|
for (const changedFirst of [true, false]) {
|
|
it(`schedules every changed occurrence (changed one ${changedFirst ? 'first' : 'last'})`, async function() {
|
|
const uid = `rrule-several-occurrences-${changedFirst ? 'first' : 'last'}`
|
|
const icsName = `${uid}.ics`
|
|
icsList.push(icsName)
|
|
|
|
// 1. Move the occurrence of the 22nd. The attendee receives it
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Weekly sync'), _exception(uid, '22', 'NEEDS-ACTION')))
|
|
expect(await _attendeeStartOf(icsName, '22')).toBe('20261022T110000Z')
|
|
|
|
// 2. Move the occurrence of the 8th as well. The 22nd is sent back with
|
|
// a different PARTSTAT, as a client holding an older copy would do.
|
|
const moved = _exception(uid, '08', 'NEEDS-ACTION')
|
|
const untouched = _exception(uid, '22', 'ACCEPTED')
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(_master(uid, 'Weekly sync'),
|
|
...(changedFirst ? [moved, untouched] : [untouched, moved])), 204)
|
|
|
|
expect(await _attendeeStartOf(icsName, '08'))
|
|
.withContext('Occurrence of the 8th moved in the calendar of the attendee')
|
|
.toBe('20261008T110000Z')
|
|
expect(await _attendeeStartOf(icsName, '22'))
|
|
.withContext('Occurrence of the 22nd still moved in the calendar of the attendee')
|
|
.toBe('20261022T110000Z')
|
|
})
|
|
}
|
|
|
|
it('schedules several occurrences moved in the same PUT', async function() {
|
|
const uid = 'rrule-several-occurrences-moved'
|
|
const icsName = `${uid}.ics`
|
|
icsList.push(icsName)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Weekly sync'), _exception(uid, '22', 'NEEDS-ACTION')))
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Weekly sync'), _exception(uid, '08', 'NEEDS-ACTION'),
|
|
_exception(uid, '15', 'NEEDS-ACTION'), _exception(uid, '22', 'NEEDS-ACTION')), 204)
|
|
|
|
for (const day of ['08', '15', '22']) {
|
|
expect(await _attendeeStartOf(icsName, day))
|
|
.withContext(`Occurrence of the ${day} moved in the calendar of the attendee`)
|
|
.toBe(`202610${day}T110000Z`)
|
|
}
|
|
})
|
|
|
|
it('cancels a moved occurrence replaced by an EXDATE', async function() {
|
|
const uid = 'rrule-moved-occurrence-cancelled'
|
|
const icsName = `${uid}.ics`
|
|
icsList.push(icsName)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Weekly sync'), _exception(uid, '15', 'NEEDS-ACTION'),
|
|
_exception(uid, '22', 'NEEDS-ACTION')))
|
|
|
|
// Drop the occurrence of the 22nd and exclude it from the series
|
|
const master = _master(uid, 'Weekly sync')
|
|
master.splice(-1, 0, 'EXDATE:20261022T130000Z')
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
master, _exception(uid, '15', 'NEEDS-ACTION')), 204)
|
|
|
|
const vcalendar = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
const vevents = vcalendar.getAllSubcomponents('vevent')
|
|
expect(await _attendeeStartOf(icsName, '22'))
|
|
.withContext('Occurrence of the 22nd removed from the calendar of the attendee')
|
|
.toBeUndefined()
|
|
expect(vevents.find(e => !e.hasProperty('recurrence-id')).hasProperty('exdate'))
|
|
.withContext('Master event of the attendee excludes the 22nd')
|
|
.toBe(true)
|
|
expect(await _attendeeStartOf(icsName, '15'))
|
|
.withContext('Occurrence of the 15th still moved in the calendar of the attendee')
|
|
.toBe('20261015T110000Z')
|
|
})
|
|
|
|
it('schedules the master event along with a changed occurrence', async function() {
|
|
const uid = 'rrule-master-and-occurrence'
|
|
const icsName = `${uid}.ics`
|
|
icsList.push(icsName)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Weekly sync'), _exception(uid, '22', 'NEEDS-ACTION')))
|
|
|
|
// Rename the series and move the occurrence of the 8th in the same PUT
|
|
await _putEvent(webdav, userCalendar, icsName, _calendar(
|
|
_master(uid, 'Renamed sync'), _exception(uid, '08', 'NEEDS-ACTION'),
|
|
_exception(uid, '22', 'NEEDS-ACTION')), 204)
|
|
|
|
const vcalendar = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
const master = vcalendar.getAllSubcomponents('vevent').find(e => !e.hasProperty('recurrence-id'))
|
|
expect(master.getFirstPropertyValue('summary'))
|
|
.withContext('Summary of the master event in the calendar of the attendee')
|
|
.toBe('Renamed sync')
|
|
expect(await _attendeeStartOf(icsName, '08'))
|
|
.withContext('Occurrence of the 8th moved in the calendar of the attendee')
|
|
.toBe('20261008T110000Z')
|
|
})
|
|
})
|
|
|
|
it ('RRULE invitation delete exdate dance', async function() {
|
|
// Workflow:
|
|
// Create an recurring event and invite Bob
|
|
// Add an exdate to the master event
|
|
// Verify that the exdate has propagated to Bob's calendar
|
|
// Add an exdate to bob's version of the event
|
|
// Verify that an exception has been created in the org's calendar and that bob is 'declined'
|
|
|
|
const icsName = 'test-rrule-invitation-deleted-exdate-dance.ics'
|
|
icsList.push(icsName)
|
|
|
|
let summary, uid, rrule, recur, organizer, attendees, attendee, nstartdate, exdate, tzid, timezone, offset, offsetException
|
|
let vcalendar, vtimezone, vcalendarOrganizer, vcalendarAttendee, vevent, vevents, veventMaster, veventException
|
|
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdavAttendee1, attendee1Calendar + icsName)
|
|
|
|
// 1. create a recurring event in the organizer's calendar
|
|
summary = 'Test rrule invitation deleted exdate dance'
|
|
uid = 'Test-rrule-invitation-deleted-exdate-dance'
|
|
vcalendar = utility.createCalendar(summary, uid)
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
rrule = new ICAL.Property('rrule')
|
|
recur = new ICAL.Recur({ freq: 'DAILY', count: 5 })
|
|
rrule.setValue(recur)
|
|
vevent.addProperty(rrule)
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setParameter('partstat', 'ACCEPTED')
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('role', 'REQ-PARTICIPANT')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. Make sure the attendee got it
|
|
await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
|
|
// 3. Add exdate to master event
|
|
vcalendarOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
vevent = vcalendarOrganizer.getFirstSubcomponent('vevent')
|
|
nstartdate = vevent.getFirstProperty('dtstart').getFirstValue()
|
|
|
|
vtimezone = vcalendarOrganizer.getFirstSubcomponent('vtimezone')
|
|
tzid = vtimezone.getFirstPropertyValue('tzid')
|
|
timezone = new ICAL.Timezone({
|
|
component: vtimezone,
|
|
tzid
|
|
})
|
|
offset = timezone.utcOffset(nstartdate)
|
|
|
|
exdate = nstartdate.convertToZone(ICAL.Timezone.utcTimezone)
|
|
exdate.addDuration(new ICAL.Duration({ seconds: -offset }))
|
|
vevent.addPropertyWithValue('exdate', exdate)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarOrganizer, 204)
|
|
|
|
// 4. make sure the attendee has the exdate
|
|
vcalendarAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
vevent = vcalendarAttendee.getFirstSubcomponent('vevent')
|
|
expect(vevent.getFirstProperty('exdate').getFirstValue().toICALString())
|
|
.withContext(`Exdate is in attendee's calendar`)
|
|
.toEqual(exdate.toICALString())
|
|
|
|
// 5. Create an exdate in the attendee's calendar
|
|
exdate = nstartdate.convertToZone(ICAL.Timezone.utcTimezone)
|
|
exdate.addDuration(new ICAL.Duration({ days: 2, seconds: -offset }))
|
|
offsetException = timezone.utcOffset(exdate)
|
|
if (offset != offsetException)
|
|
// Adjust for Daylight Saving Time
|
|
exdate.addDuration(new ICAL.Duration({ seconds: (offset-offsetException) }))
|
|
vevent.addPropertyWithValue('exdate', exdate)
|
|
vevent.removeProperty('last-modified')
|
|
vevent.addProperty(utility.createDateTimeProperty('last-modified'))
|
|
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, icsName, vcalendarAttendee, 204)
|
|
|
|
// 6. Make sure the attendee is:
|
|
// needs-action in master event
|
|
// declined in the new exception created by the exdate above
|
|
vcalendarOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
vevents = vcalendarOrganizer.getAllSubcomponents('vevent')
|
|
for (vevent of vevents) {
|
|
if (vevent.getFirstPropertyValue('recurrence-id'))
|
|
veventException = vevent
|
|
else
|
|
veventMaster = vevent
|
|
}
|
|
|
|
attendees = veventMaster.getAllProperties('attendee')
|
|
expect(attendees.length)
|
|
.withContext('Attendees count in the calendar of the master event')
|
|
.toBe(1)
|
|
attendee = attendees[0]
|
|
expect(attendee.getParameter('partstat'))
|
|
.withContext('Partstat of attendee is need-actions for the master event')
|
|
.toBe('NEEDS-ACTION')
|
|
|
|
expect(veventException)
|
|
.withContext(`The vCalendar of the organizer has a vEvent with a recurrence-id: ${vcalendarOrganizer}`)
|
|
.toBeTruthy()
|
|
attendees = veventException.getAllProperties('attendee')
|
|
expect(attendees.length)
|
|
.withContext('Attendees count in the calendar of the exception event')
|
|
.toBe(1)
|
|
attendee = attendees[0]
|
|
expect(attendee.getParameter('partstat'))
|
|
.withContext('Partstat of attendee is declined for the exception')
|
|
.toBe('DECLINED')
|
|
})
|
|
|
|
it('iCal organizer is attendee - bug #1839', async function() {
|
|
const icsName = 'test-organizer-is-attendee.ics'
|
|
icsList.push(icsName)
|
|
|
|
let summary, uid
|
|
let vcalendar, vcalendarOrganizer, vevent, organizer, attendee, attendees
|
|
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdavAttendee1, attendee1Calendar + icsName)
|
|
|
|
// 1. create a recurring event in the organizer's calendar
|
|
summary = 'Test organizer is attendee'
|
|
uid = 'Test-organizer-is-attendee'
|
|
vcalendar = utility.createCalendar(summary, uid)
|
|
vevent = vcalendar.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setParameter('partstat', 'ACCEPTED')
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('role', 'REQ-PARTICIPANT')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
// 1.1 add the organizer as an attendee
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', user.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('role', 'REQ-PARTICIPANT')
|
|
attendee.setParameter('partstat', 'ACCEPTED')
|
|
attendee.setValue(user.email)
|
|
vevent.addProperty(attendee)
|
|
// console.debug(`Test organizer is attendee =\n${vcalendar.toString()}`)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// 2. Fetch the event and make sure the organizer is not in the attendee list anymore
|
|
vcalendarOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
vevent = vcalendarOrganizer.getFirstSubcomponent('vevent')
|
|
attendees = vevent.getAllProperties('attendee')
|
|
for (attendee of attendees) {
|
|
expect(attendee.getFirstValue())
|
|
.withContext(`Organizer is not an attendee`)
|
|
.not.toBe(user.email)
|
|
}
|
|
})
|
|
|
|
it('PUT 2 events with the same UID - bug #1853', async function () {
|
|
const icsName = 'test-same-uid.ics'
|
|
const conflictIcsName = 'test-same-uid-conflict.ics'
|
|
icsList.push(icsName, conflictIcsName)
|
|
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdav, userCalendar + conflictIcsName)
|
|
|
|
let summary, uid
|
|
let vcalendar
|
|
|
|
// 1. create simple event
|
|
summary = 'Test same uid'
|
|
uid = 'Test-same-uid'
|
|
vcalendar = utility.createCalendar(summary, uid)
|
|
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendar)
|
|
|
|
// PUT the same event with a new filename - should trigger a 409
|
|
await _putEvent(webdav, userCalendar, conflictIcsName, vcalendar, 409)
|
|
})
|
|
|
|
it('invitation delegation', async function () {
|
|
const icsName = 'test-delegation.ics'
|
|
icsList.push(icsName)
|
|
|
|
let vcalendarInvitation, vcalendarInvitationAttendee, vcalendarInvitationDelegate, vcalendarInvitationOrganizer, vcalendarCancellation
|
|
let vevent, organizer, attendee, attendees, delegate
|
|
|
|
// the invitation must not exist
|
|
await _deleteEvent(webdav, userCalendar + icsName)
|
|
await _deleteEvent(webdavAttendee1, attendee1Calendar + icsName)
|
|
await _deleteEvent(webdavAttendee1Delegate, attendee1DelegateCalendar + icsName)
|
|
|
|
// 1. org -> attendee => org: 1, attendee: 1 (pst=N-A), delegate: 0
|
|
vcalendarInvitation = utility.createCalendar()
|
|
vcalendarInvitation.addPropertyWithValue('method', 'REQUEST')
|
|
vevent = vcalendarInvitation.getFirstSubcomponent('vevent')
|
|
organizer = new ICAL.Property('organizer')
|
|
organizer.setParameter('cn', user.displayname)
|
|
organizer.setValue(user.email)
|
|
vevent.addProperty(organizer)
|
|
attendee = new ICAL.Property('attendee')
|
|
attendee.setParameter('cn', attendee1.displayname)
|
|
attendee.setParameter('rsvp', 'TRUE')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
attendee.setValue(attendee1.email)
|
|
vevent.addProperty(attendee)
|
|
|
|
await _postEvent(webdav, userCalendar, vcalendarInvitation, user.email, [attendee1.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarInvitation)
|
|
|
|
vcalendarInvitationAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
_compareAttendees(vcalendarInvitationAttendee, vcalendarInvitation)
|
|
|
|
// 2. attendee delegates to delegate
|
|
// => org: 1 (updated), attendee: 1 (updated,pst=D),
|
|
// delegate: 1 (new,pst=N-A)
|
|
vcalendarInvitation.addPropertyWithValue('method', 'REQUEST')
|
|
attendee.setParameter('partstat', 'DELEGATED')
|
|
attendee.setParameter('delegated-to', attendee1Delegate.email)
|
|
delegate = new ICAL.Property('attendee')
|
|
delegate.setParameter('delegated-from', attendee1.email)
|
|
delegate.setParameter('cn', attendee1Delegate.displayname)
|
|
delegate.setParameter('rsvp', 'TRUE')
|
|
delegate.setParameter('partstat', 'NEEDS-ACTION')
|
|
delegate.setValue(attendee1Delegate.email)
|
|
vevent.addProperty(delegate)
|
|
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarInvitation, attendee1.email, [attendee1Delegate.email])
|
|
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REPLY')
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarInvitation, attendee1.email, [user.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationDelegate = await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationDelegate, vcalendarInvitation)
|
|
|
|
// 3. delegate accepts
|
|
// => org: 1 (updated), attendee: 1 (updated,pst=D),
|
|
// delegate: 1 (accepted,pst=A)
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REQUEST')
|
|
delegate.setParameter('partstat', 'ACCEPTED')
|
|
await _postEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, vcalendarInvitation, attendee1Delegate.email, [user.email, attendee1.email])
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationOrganizer, vcalendarInvitation)
|
|
|
|
// 4. attendee accepts
|
|
// => org: 1 (updated), attendee: 1 (updated,pst=A),
|
|
// delegate: 0 (cancelled, deleted)
|
|
vcalendarCancellation = utility.createCalendar()
|
|
vcalendarCancellation.addPropertyWithValue('method', 'CANCEL')
|
|
attendees = vevent.getAllProperties('attendee')
|
|
vevent = vcalendarCancellation.getFirstSubcomponent('vevent')
|
|
vevent.updatePropertyWithValue('sequence', '1')
|
|
vevent.addProperty(ICAL.Property.fromString(organizer.toICALString()))
|
|
for (attendee of attendees) {
|
|
vevent.addProperty(ICAL.Property.fromString(attendee.toICALString()))
|
|
}
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarCancellation, attendee1.email, [attendee1Delegate.email])
|
|
|
|
vevent = vcalendarInvitation.getFirstSubcomponent('vevent')
|
|
for (attendee of attendees) {
|
|
if (attendee.getParameter('delegated-to')) {
|
|
// console.debug(`delegated-to = ${attendee.toICALString()}`)
|
|
attendee.removeParameter('delegated-to')
|
|
attendee.setParameter('partstat', 'ACCEPTED')
|
|
} else {
|
|
// Remove delegate attendee
|
|
vevent.removeProperty(attendee)
|
|
}
|
|
}
|
|
vcalendarInvitation.addPropertyWithValue('method', 'REPLY')
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarInvitation, attendee1.email, [user.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationOrganizer, vcalendarInvitation)
|
|
|
|
// vcalendarInvitationDelegate = await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName, 404)
|
|
|
|
// 5. org updates inv.
|
|
// => org: 1 (updated), attendee: 1 (updated), delegate: 0
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REQUEST')
|
|
vevent.updatePropertyWithValue('sequence', '1')
|
|
vevent.updatePropertyWithValue('last-modified', utility.createDateTimeProperty('last-modified').getFirstValue())
|
|
vevent.updatePropertyWithValue('dtstamp', utility.createDateTimeProperty('dtstamp').getFirstValue())
|
|
attendee = vevent.getFirstProperty('attendee')
|
|
attendee.setParameter('partstat', 'NEEDS-ACTION')
|
|
|
|
await _postEvent(webdav, userCalendar, vcalendarInvitation, user.email, [attendee1.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
_compareAttendees(vcalendarInvitationAttendee, vcalendarInvitation)
|
|
|
|
// 6. attendee delegates to delegate
|
|
// => org: 1 (updated), attendee: 1 (updated), delegate: 1 (new)
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REQUEST')
|
|
attendee.setParameter('partstat', 'DELEGATED')
|
|
attendee.setParameter('delegated-to', attendee1Delegate.email)
|
|
delegate = new ICAL.Property('attendee')
|
|
delegate.setParameter('delegated-from', attendee1.email)
|
|
delegate.setParameter('cn', attendee1Delegate.displayname)
|
|
delegate.setParameter('rsvp', 'TRUE')
|
|
delegate.setParameter('partstat', 'NEEDS-ACTION')
|
|
delegate.setValue(attendee1Delegate.email)
|
|
vevent.addProperty(delegate)
|
|
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarInvitation, attendee1.email, [attendee1Delegate.email])
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REPLY')
|
|
await _postEvent(webdavAttendee1, attendee1Calendar, vcalendarInvitation, attendee1.email, [user.email])
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdavAttendee1, attendee1Calendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationOrganizer, vcalendarInvitation)
|
|
|
|
vcalendarInvitationDelegate = await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationDelegate, vcalendarInvitation)
|
|
|
|
// 7. delegate accepts
|
|
// => org: 1 (updated), attendee: 1 (updated), delegate: 1 (accepted)
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REPLY')
|
|
delegate.setParameter('partstat', 'ACCEPTED')
|
|
await _postEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, vcalendarInvitation, attendee1Delegate.email, [user.email, attendee1.email])
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationOrganizer = await _getEvent(webdav, userCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationOrganizer, vcalendarInvitation)
|
|
vcalendarInvitationAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
_compareAttendees(vcalendarInvitationAttendee, vcalendarInvitation)
|
|
|
|
// 8. org updates inv.
|
|
// => org: 1 (updated), attendee: 1 (updated,partstat unchanged),
|
|
// delegate: 1 (updated,partstat reset)
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'REQUEST')
|
|
vevent.updatePropertyWithValue('sequence', '2')
|
|
vevent.updatePropertyWithValue('last-modified', utility.createDateTimeProperty('last-modified').getFirstValue())
|
|
vevent.updatePropertyWithValue('dtstamp', utility.createDateTimeProperty('dtstamp').getFirstValue())
|
|
delegate.setParameter('partstat', 'NEEDS-ACTION')
|
|
|
|
await _postEvent(webdav, userCalendar, vcalendarInvitation, user.email, [attendee1.email, attendee1DelegateCalendar.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName)
|
|
_compareAttendees(vcalendarInvitationAttendee, vcalendarInvitation)
|
|
|
|
vcalendarInvitationDelegate = await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName)
|
|
_compareAttendees(vcalendarInvitationDelegate, vcalendarInvitation)
|
|
|
|
// 9. org cancels invitation
|
|
// => org: 1 (updated), attendee: 0 (cancelled, deleted),
|
|
// delegate: 0 (cancelled, deleted)
|
|
vcalendarInvitation.updatePropertyWithValue('method', 'CANCEL')
|
|
vevent.updatePropertyWithValue('sequence', '3')
|
|
vevent.updatePropertyWithValue('last-modified', utility.createDateTimeProperty('last-modified').getFirstValue())
|
|
vevent.updatePropertyWithValue('dtstamp', utility.createDateTimeProperty('dtstamp').getFirstValue())
|
|
|
|
await _postEvent(webdav, userCalendar, vcalendarInvitation, user.email, [attendee1.email, attendee1DelegateCalendar.email])
|
|
|
|
vcalendarInvitation.removeProperty('method')
|
|
vevent.removeProperty(attendee)
|
|
vevent.removeProperty(delegate)
|
|
await _putEvent(webdav, userCalendar, icsName, vcalendarInvitation, 204)
|
|
|
|
vcalendarInvitationAttendee = await _getEvent(webdavAttendee1, attendee1Calendar, icsName, 404)
|
|
vcalendarInvitationDelegate = await _getEvent(webdavAttendee1Delegate, attendee1DelegateCalendar, icsName, 404)
|
|
}) // increase timeout for this long test
|
|
}) |