From 69cbd001317f5262fa5db37261c38cb69f7decce Mon Sep 17 00:00:00 2001 From: SebastianKrupinski Date: Sun, 19 Oct 2025 20:15:38 -0400 Subject: [PATCH 1/4] fix: update, delete, accept, devline all occurrences Signed-off-by: SebastianKrupinski --- .../Editor/InvitationResponseButtons.vue | 60 ++++-- src/components/Editor/Repeat/Repeat.vue | 33 ++- src/components/Editor/SaveButtons.vue | 78 ++++--- src/mixins/EditorMixin.js | 149 +++++++++----- src/models/event.js | 2 - src/store/calendarObjectInstance.js | 120 +++++++++-- src/views/EditFull.vue | 52 ++--- src/views/EditSimple.vue | 35 ++-- .../InvitationResponseButtons.test.js | 41 ++++ .../javascript/unit/components/Repeat.test.js | 31 +++ .../unit/components/SaveButtons.test.js | 57 +++++ .../unit/mixins/EditorMixin.test.js | 194 +++++++++++++++++- tests/javascript/unit/models/event.test.js | 15 -- .../unit/store/calendarObjectInstance.test.ts | 143 ++++++++++++- 14 files changed, 824 insertions(+), 186 deletions(-) create mode 100644 tests/javascript/unit/components/InvitationResponseButtons.test.js create mode 100644 tests/javascript/unit/components/Repeat.test.js create mode 100644 tests/javascript/unit/components/SaveButtons.test.js diff --git a/src/components/Editor/InvitationResponseButtons.vue b/src/components/Editor/InvitationResponseButtons.vue index ea91e53835..30c3a5ddd2 100644 --- a/src/components/Editor/InvitationResponseButtons.vue +++ b/src/components/Editor/InvitationResponseButtons.vue @@ -13,7 +13,7 @@ class="invitation-response-buttons__button" :disabled="loading" @click="accept"> - {{ t('calendar', 'Accept') }} + {{ acceptLabel }} - {{ t('calendar', 'Decline') }} + {{ declineLabel }} - {{ t('calendar', 'Tentative') }} + {{ tentativeLabel }} @@ -72,11 +72,6 @@ export default { required: true, }, - calendarId: { - type: String, - required: true, - }, - narrow: { type: Boolean, default: false, @@ -109,6 +104,45 @@ export default { isTentative() { return this.attendee.participationStatus === 'TENTATIVE' }, + + responseScope() { + const eventComponent = this.calendarObjectInstanceStore.calendarObjectInstance?.eventComponent + if (!eventComponent?.isPartOfRecurrenceSet()) { + return null + } + + return eventComponent.isRecurrenceException() ? 'occurrence' : 'series' + }, + + acceptLabel() { + if (this.responseScope === 'occurrence') { + return this.t('calendar', 'Accept this occurrence') + } + if (this.responseScope === 'series') { + return this.t('calendar', 'Accept entire series') + } + return this.t('calendar', 'Accept') + }, + + declineLabel() { + if (this.responseScope === 'occurrence') { + return this.t('calendar', 'Decline this occurrence') + } + if (this.responseScope === 'series') { + return this.t('calendar', 'Decline entire series') + } + return this.t('calendar', 'Decline') + }, + + tentativeLabel() { + if (this.responseScope === 'occurrence') { + return this.t('calendar', 'Tentative for this occurrence') + } + if (this.responseScope === 'series') { + return this.t('calendar', 'Tentative for entire series') + } + return this.t('calendar', 'Tentative') + }, }, methods: { @@ -154,16 +188,10 @@ export default { async setParticipationStatus(participationStatus) { this.loading = true try { - this.calendarObjectInstanceStore.changeAttendeesParticipationStatus({ + await this.calendarObjectInstanceStore.saveAttendeeParticipationResponse({ attendee: this.attendee, participationStatus, }) - // TODO: What about recurring events? Add new buttons like "Accept this and all future"? - // Currently, this will only accept a single occurrence. - await this.calendarObjectInstanceStore.saveCalendarObjectInstance({ - thisAndAllFuture: false, - calendarId: this.calendarId, - }) } catch (error) { logger.error('Failed to set participation status', { error, participationStatus }) throw error diff --git a/src/components/Editor/Repeat/Repeat.vue b/src/components/Editor/Repeat/Repeat.vue index f5f655ef40..47cc3686a0 100644 --- a/src/components/Editor/Repeat/Repeat.vue +++ b/src/components/Editor/Repeat/Repeat.vue @@ -33,18 +33,18 @@

{{ $t('calendar', 'Repeat event') }}

- - + +
{{ $t('calendar', 'Set repetition') }} @@ -137,26 +137,25 @@ export default { }, /** - * Whether or not the user is editing the master-item - * If so, we are enforcing "This and all future" and - * don't allow to just save this occurrence + * Whether or not the user is editing the base instance. + * Recurrence-rule changes on a non-base instance require a future update. */ - isEditingMasterItem: { + isEditingBaseInstance: { type: Boolean, required: true, }, /** - * Whether or not this instance of the event is a recurrence-exception. + * Whether or not the user is editing a recurrence-exception. * If yes, you can't modify the recurrence-rule */ - isRecurrenceException: { + isEditingExceptionInstance: { type: Boolean, required: true, }, }, - emits: ['forceThisAndAllFuture'], + emits: ['requireFutureUpdate'], data() { return { @@ -468,8 +467,8 @@ export default { }) } - if (!this.isEditingMasterItem) { - this.$emit('forceThisAndAllFuture') + if (!this.isEditingBaseInstance) { + this.$emit('requireFutureUpdate') } this.calendarObjectInstanceStore.calendarObjectInstance.canModifyAllDay = this.calendarObjectInstanceStore.calendarObjectInstance.eventComponent.canModifyAllDay() diff --git a/src/components/Editor/SaveButtons.vue b/src/components/Editor/SaveButtons.vue index 30b64eb7fc..aca3db961a 100644 --- a/src/components/Editor/SaveButtons.vue +++ b/src/components/Editor/SaveButtons.vue @@ -16,7 +16,7 @@ v-if="showSaveButton" variant="primary" :disabled="disabled" - @click="saveThisOnly"> + @click="saveOccurrence"> @@ -26,38 +26,43 @@ v-if="showUpdateButton" variant="primary" :disabled="disabled" - @click="saveThisOnly"> + @click="saveOccurrence"> {{ $t('calendar', 'Update') }} - {{ $t('calendar', 'Update this and all future') }} + @click="saveSeries"> + {{ $t('calendar', 'Update entire series') }} - {{ $t('calendar', 'Update this occurrence') }} + @click="saveFuture"> + {{ $t('calendar', 'Update this and future occurrences') }} - - + - + + + {{ $t('calendar', 'Update entire series') }} + + - {{ $t('calendar', 'Update this and all future') }} + {{ $t('calendar', 'Update this and future occurrences') }} - + @@ -86,22 +91,27 @@ export default { }, props: { - canCreateRecurrenceException: { + canUpdateOccurrence: { type: Boolean, required: true, }, - isNew: { + canUpdateFuture: { type: Boolean, required: true, }, - isReadOnly: { + canUpdateSeries: { type: Boolean, required: true, }, - forceThisAndAllFuture: { + isNew: { + type: Boolean, + required: true, + }, + + isReadOnly: { type: Boolean, required: true, }, @@ -122,33 +132,45 @@ export default { }, }, - emits: ['saveThisOnly', 'saveThisAndAllFuture', 'showMore'], + emits: ['saveOccurrence', 'saveFuture', 'saveSeries', 'showMore'], computed: { showSaveButton() { - return !this.isReadOnly && this.isNew && !this.canCreateRecurrenceException + return !this.isReadOnly && this.isNew }, showUpdateButton() { - return !this.isReadOnly && !this.isNew && !this.canCreateRecurrenceException + return !this.isReadOnly && !this.isNew && this.allowedUpdateScopeCount === 1 && this.canUpdateOccurrence + }, + + allowedUpdateScopeCount() { + return [this.canUpdateOccurrence, this.canUpdateFuture, this.canUpdateSeries].filter(Boolean).length }, - showUpdateOnlyThisButton() { - return !this.isReadOnly && this.canCreateRecurrenceException && !this.forceThisAndAllFuture + showUpdateFutureButton() { + return !this.isReadOnly && !this.isNew && this.allowedUpdateScopeCount === 1 && this.canUpdateFuture }, - showUpdateThisAndFutureButton() { - return !this.isReadOnly && this.canCreateRecurrenceException + showUpdateSeriesButton() { + return !this.isReadOnly && !this.isNew && this.allowedUpdateScopeCount === 1 && this.canUpdateSeries + }, + + showUpdateMenu() { + return !this.isReadOnly && !this.isNew && this.allowedUpdateScopeCount > 1 }, }, methods: { - saveThisOnly() { - this.$emit('saveThisOnly') + saveOccurrence() { + this.$emit('saveOccurrence') + }, + + saveFuture() { + this.$emit('saveFuture') }, - saveThisAndAllFuture() { - this.$emit('saveThisAndAllFuture') + saveSeries() { + this.$emit('saveSeries') }, showMore() { diff --git a/src/mixins/EditorMixin.js b/src/mixins/EditorMixin.js index 636d787636..56941fa530 100644 --- a/src/mixins/EditorMixin.js +++ b/src/mixins/EditorMixin.js @@ -50,13 +50,12 @@ export default { calendarId: null, // Whether or not an action is required on leave requiresActionOnRouteLeave: true, - // Whether or not the this and all future option will be forced - // This is the case when editing the recurrence-rule of an existing recurring event - forceThisAndAllFuture: false, - // Whether or not the master item is being edited - isEditingMasterItem: false, - // Whether or not it is a recurrence-exception - isRecurrenceException: false, + // Whether changing the recurrence rule requires updating this and future occurrences + requiresFutureUpdate: false, + // Whether or not the base item is being edited + isEditingBaseInstance: false, + // Whether or not a recurrence-exception is being edited + isEditingExceptionInstance: false, // Whether or not the Talk modal is open isTalkModalOpen: false, } @@ -309,22 +308,12 @@ export default { return this.viewMode === ViewMode.USER }, /** - * Returns whether or not the user is allowed to delete this event + * Returns whether the current event is a recurring instance or exception. * * @return {boolean} */ - canDelete() { - if (!this.calendarObject) { - return false - } - if (this.isReadOnly) { - return false - } - if (this.isLoading) { - return false - } - - return this.calendarObject?.existsOnServer ?? false + isRecurringInstance() { + return this.canCreateRecurrenceException || this.isEditingExceptionInstance }, /** * Returns whether or not the user is allowed to create recurrence exceptions for this event @@ -487,6 +476,9 @@ export default { this.addDelegatorAsAttendeeIfNeeded(this.selectedCalendar) } + // A new event has no recurrence-id, so it is always its own base item + this.isEditingBaseInstance = true + logger.debug('[Editor] New event created successfully') } catch (error) { logger.error('[Editor] Error creating new event:', { error }) @@ -504,8 +496,8 @@ export default { await this.loadingCalendars() await this.calendarObjectInstanceStore.getCalendarObjectInstanceByObjectIdAndRecurrenceId({ objectId, recurrenceId }) this.calendarId = this.calendarObject.calendarId - this.isEditingMasterItem = this.eventComponent.isMasterItem() - this.isRecurrenceException = this.eventComponent.isRecurrenceException() + this.isEditingBaseInstance = this.eventComponent.isMasterItem() + this.isEditingExceptionInstance = this.eventComponent.isRecurrenceException() logger.debug('[Editor] Event loaded successfully') } catch (error) { logger.error('[Editor] Error loading event:', { error }) @@ -575,10 +567,10 @@ export default { } }, /** - * This will force the user to update this and all future occurrences when saving + * Require recurrence changes to apply to this and future occurrences. */ - forceModifyingFuture() { - this.forceThisAndAllFuture = true + requireFutureUpdate() { + this.requiresFutureUpdate = true }, /** * Closes the editor and returns to normal calendar-view @@ -648,13 +640,13 @@ export default { } }, keyboardSaveEvent(event) { - if (event.key === 'Enter' && event.ctrlKey === true && !this.isReadOnly && !this.canCreateRecurrenceException) { - this.saveAndLeave(false) + if (event.key === 'Enter' && event.ctrlKey === true && !this.isRecurringInstance && this.canUpdate('occurrence')) { + this.saveAndLeave('occurrence') } }, keyboardDeleteEvent(event) { - if (event.key === 'Delete' && event.ctrlKey === true && this.canDelete && !this.canCreateRecurrenceException) { - this.deleteAndLeave(false) + if (event.key === 'Delete' && event.ctrlKey === true && !this.isRecurringInstance && this.canDelete('occurrence')) { + this.deleteAndLeave('occurrence') } }, keyboardDuplicateEvent(event) { @@ -668,26 +660,26 @@ export default { /** * Saves a calendar-object * - * @param {boolean} thisAndAllFuture Whether to modify only this or this and all future occurrences + * @param {string} scope Modification scope: 'occurrence', 'future', or 'series' * @return {Promise} */ - async save(thisAndAllFuture = false) { + async save(scope = 'occurrence') { if (!this.calendarObject) { logger.error('Calendar-object not found') return } - if (this.isReadOnly) { - return + if (this.requiresFutureUpdate) { + scope = 'future' } - if (this.forceThisAndAllFuture) { - thisAndAllFuture = true + if (!this.canUpdate(scope)) { + return } this.isLoading = true this.isSaving = true try { await this.calendarObjectInstanceStore.saveCalendarObjectInstance({ - thisAndAllFuture, + scope, calendarId: this.calendarId, }) } catch (error) { @@ -703,14 +695,43 @@ export default { } }, + /** + * Returns whether the current user can update the event with the given scope. + * + * @param {string} scope Modification scope: 'occurrence', 'future', or 'series' + * @return {boolean} + */ + canUpdate(scope) { + if (!this.calendarObject || this.isReadOnly || this.isLoading) { + return false + } + if (this.isNew) { + return scope === 'occurrence' + } + if (!this.calendarObject.existsOnServer) { + return false + } + if (this.requiresFutureUpdate) { + return scope === 'future' + } + if (!this.isRecurringInstance) { + return scope === 'occurrence' + } + if (this.isViewedByAttendee) { + return scope === 'series' || (this.isEditingExceptionInstance && scope === 'occurrence') + } + + return ['occurrence', 'future', 'series'].includes(scope) + }, + /** * Saves a calendar-object and closes the editor * - * @param {boolean} thisAndAllFuture Whether to modify only this or this and all future occurrences + * @param {string} scope Modification scope: 'occurrence', 'future', or 'series' * @return {Promise} */ - async saveAndLeave(thisAndAllFuture = false) { - await this.save(thisAndAllFuture) + async saveAndLeave(scope = 'occurrence') { + await this.save(scope) this.requiresActionOnRouteLeave = false this.closeEditor() }, @@ -755,36 +776,58 @@ export default { } }, + /** + * Returns whether the current user can delete the event with the given scope. + * + * @param {string} scope Deletion scope: 'occurrence', 'future', or 'series' + * @return {boolean} + */ + canDelete(scope) { + if (!this.calendarObject || this.isReadOnly || this.isLoading || !this.calendarObject.existsOnServer) { + return false + } + if (!this.isRecurringInstance) { + return scope === 'occurrence' + } + if (this.isViewedByAttendee) { + return scope === 'series' || (this.isEditingExceptionInstance && scope === 'occurrence') + } + + return ['occurrence', 'future', 'series'].includes(scope) + }, + /** * Deletes a calendar-object * - * @param {boolean} thisAndAllFuture Whether to delete only this or this and all future occurrences + * @param {string} scope Deletion scope: 'occurrence', 'future', or 'series' * @return {Promise} */ - async delete(thisAndAllFuture = false) { + async delete(scope = 'occurrence') { if (!this.calendarObject) { logger.error('Calendar-object not found') return } - if (this.isReadOnly) { + if (!this.canDelete(scope)) { return } this.isLoading = true - await this.calendarObjectInstanceStore.deleteCalendarObjectInstance({ thisAndAllFuture }) + await this.calendarObjectInstanceStore.deleteCalendarObjectInstance({ scope }) this.isLoading = false }, + /** * Deletes a calendar-object and closes the editor * - * @param {boolean} thisAndAllFuture Whether to delete only this or this and all future occurrences + * @param {string} scope Deletion scope: 'occurrence', 'future', or 'series' * @return {Promise} */ - async deleteAndLeave(thisAndAllFuture = false) { - await this.delete(thisAndAllFuture) + async deleteAndLeave(scope = 'occurrence') { + await this.delete(scope) this.requiresActionOnRouteLeave = false this.closeEditor() }, + /** * Updates the title of this event * @@ -926,9 +969,9 @@ export default { this.error = null this.calendarId = null this.requiresActionOnRouteLeave = true - this.forceThisAndAllFuture = false - this.isEditingMasterItem = false - this.isRecurrenceException = false + this.requiresFutureUpdate = false + this.isEditingBaseInstance = false + this.isEditingExceptionInstance = false }, /** * This function returns a promise that resolves @@ -1010,8 +1053,8 @@ export default { await vm.loadingCalendars() await vm.calendarObjectInstanceStore.getCalendarObjectInstanceByObjectIdAndRecurrenceId({ objectId, recurrenceId }) vm.calendarId = vm.calendarObject.calendarId - vm.isEditingMasterItem = vm.eventComponent.isMasterItem() - vm.isRecurrenceException = vm.eventComponent.isRecurrenceException() + vm.isEditingBaseInstance = vm.eventComponent.isMasterItem() + vm.isEditingExceptionInstance = vm.eventComponent.isRecurrenceException() } catch (error) { logger.debug(error) vm.isError = true @@ -1090,8 +1133,8 @@ export default { await this.loadingCalendars() await this.calendarObjectInstanceStore.getCalendarObjectInstanceByObjectIdAndRecurrenceId({ objectId, recurrenceId }) this.calendarId = this.calendarObject.calendarId - this.isEditingMasterItem = this.eventComponent.isMasterItem() - this.isRecurrenceException = this.eventComponent.isRecurrenceException() + this.isEditingBaseInstance = this.eventComponent.isMasterItem() + this.isEditingExceptionInstance = this.eventComponent.isRecurrenceException() } catch (error) { logger.debug(error) this.isError = true diff --git a/src/models/event.js b/src/models/event.js index 1b9640e7c6..ce237cf97e 100644 --- a/src/models/event.js +++ b/src/models/event.js @@ -56,8 +56,6 @@ function getDefaultEventObject(props = {}) { isMasterItem: false, // Whether or not this is a recurrence-exception isRecurrenceException: false, - // Whether or not the applied modifications require to update this and all future - forceThisAndAllFuture: false, // Whether or not it's possible to create a recurrence-exception for this event canCreateRecurrenceException: false, // Attendees of this event diff --git a/src/store/calendarObjectInstance.js b/src/store/calendarObjectInstance.js index f5eebe1e33..53a94c594f 100644 --- a/src/store/calendarObjectInstance.js +++ b/src/store/calendarObjectInstance.js @@ -554,6 +554,60 @@ export default defineStore('calendarObjectInstance', { attendee.rsvp = !oldRSVP }, + /** + * Change the current attendee's participation status and save it with + * the scope of the component the attendee is responding to. + * + * Responses to generated occurrences apply to the recurring master, + * while responses to existing recurrence exceptions remain on the + * exception. + * + * @param {object} data The destructuring object + * @param {object} data.attendee The attendee object + * @param {string} data.participationStatus New participation status + * @return {Promise} + */ + async saveAttendeeParticipationResponse({ + attendee, + participationStatus, + }) { + const calendarObjectsStore = useCalendarObjectsStore() + const eventComponent = this.calendarObjectInstance.eventComponent + const responseScope = eventComponent.isRecurrenceException() ? 'occurrence' : 'series' + let attendeeProperty = attendee.attendeeProperty + + if (responseScope === 'series') { + let baseComponent = null + for (const component of this.calendarObject.calendarComponent.getComponentIterator()) { + if (component.name === eventComponent.name && !component.hasProperty('RECURRENCE-ID')) { + baseComponent = component + break + } + } + + if (baseComponent === null) { + throw new Error('Recurring master component not found') + } + + const attendeeEmail = attendeeProperty.email.toLowerCase() + attendeeProperty = null + for (const masterAttendee of baseComponent.getAttendeeIterator()) { + if (masterAttendee.email.toLowerCase() === attendeeEmail) { + attendeeProperty = masterAttendee + break + } + } + + if (attendeeProperty === null) { + throw new Error('Attendee not found on recurring master component') + } + } + + attendeeProperty.participationStatus = participationStatus + attendee.participationStatus = participationStatus + await calendarObjectsStore.updateCalendarObject({ calendarObject: this.calendarObject }) + }, + /** * Set the event's organizer * @@ -1379,23 +1433,60 @@ export default defineStore('calendarObjectInstance', { * Saves changes made to a single calendar-object-instance * * @param {object} data The destructuring object - * @param {boolean} data.thisAndAllFuture Whether or not to save changes for all future occurrences or just this one + * @param {string} data.scope Modification scope: 'occurrence', 'future', or 'series' * @param {string} data.calendarId The new calendar-id to store it in * @return {Promise} */ async saveCalendarObjectInstance({ - thisAndAllFuture, + scope, calendarId, }) { const calendarObjectsStore = useCalendarObjectsStore() const eventComponent = this.calendarObjectInstance.eventComponent const calendarObject = this.calendarObject + const isForkedItem = eventComponent.primaryItem !== null updateAlarms(eventComponent) - if (eventComponent.isDirty()) { - const isForkedItem = eventComponent.primaryItem !== null + if (eventComponent.isDirty() && eventComponent.isPartOfRecurrenceSet() && scope === 'series' && isForkedItem) { + // Find the master component (without RECURRENCE-ID) + let baseComponent = null + for (const component of calendarObject.calendarComponent.getComponentIterator()) { + if (component.name === eventComponent.name && !component.hasProperty('RECURRENCE-ID')) { + baseComponent = component + break + } + } + + if (baseComponent) { + // construct list of properties to clone + const propertyNames = [] + for (const property of baseComponent.getPropertyIterator()) { + if (property.name === 'UID' || property.name === 'RECURRENCE-ID' || property.name === 'DTSTART' || property.name === 'DTEND') { + continue + } + propertyNames.push(property.name) + baseComponent.deleteAllProperties(property.name) + } + // clone properties from eventComponent + for (const property of eventComponent.getPropertyIterator()) { + if (propertyNames.indexOf(property.name) === -1) { + continue + } + baseComponent.addProperty(property.clone()) + } + // clone alarms + baseComponent.deleteAllComponents('VALARM') + for (const alarm of eventComponent.getAlarmIterator()) { + baseComponent.addComponent(alarm.clone()) + } + } + + await calendarObjectsStore.updateCalendarObject({ calendarObject }) + } + + if (eventComponent.isDirty() && scope !== 'series') { let original = null let fork = null @@ -1403,7 +1494,7 @@ export default defineStore('calendarObjectInstance', { // - primaryItem !== null -> Is this a fork or not? // - eventComponent.canCreateRecurrenceExceptions() - Can we create a recurrence-exception for this item if (isForkedItem && eventComponent.canCreateRecurrenceExceptions()) { - [original, fork] = eventComponent.createRecurrenceException(thisAndAllFuture) + [original, fork] = eventComponent.createRecurrenceException(scope === 'future') } await calendarObjectsStore.updateCalendarObject({ calendarObject }) @@ -1461,20 +1552,25 @@ export default defineStore('calendarObjectInstance', { * Deletes a calendar-object-instance * * @param {object} data The destructuring object - * @param {boolean} data.thisAndAllFuture Whether or not to delete all future occurrences or just this one + * @param {string} data.scope Deletion scope: 'occurrence', 'future', or 'series' * @return {Promise} */ - async deleteCalendarObjectInstance({ thisAndAllFuture }) { + async deleteCalendarObjectInstance({ scope }) { const calendarObjectsStore = useCalendarObjectsStore() - const eventComponent = this.calendarObjectInstance.eventComponent - const isRecurrenceSetEmpty = eventComponent.removeThisOccurrence(thisAndAllFuture) - const calendarObject = this.calendarObject + // Singleton event or deleting all occurrences - delete the whole calendar-object + if (!eventComponent.isRecurring() || scope === 'series') { + await calendarObjectsStore.deleteCalendarObject({ calendarObject: this.calendarObject }) + return + } + + // Recurring event - remove this occurrence or this and all future + const isRecurrenceSetEmpty = eventComponent.removeThisOccurrence(scope === 'future') if (isRecurrenceSetEmpty) { - await calendarObjectsStore.deleteCalendarObject({ calendarObject }) + await calendarObjectsStore.deleteCalendarObject({ calendarObject: this.calendarObject }) } else { - await calendarObjectsStore.updateCalendarObject({ calendarObject }) + await calendarObjectsStore.updateCalendarObject({ calendarObject: this.calendarObject }) } }, diff --git a/src/views/EditFull.vue b/src/views/EditFull.vue index 8b7b23fd09..2a6181b927 100644 --- a/src/views/EditFull.vue +++ b/src/views/EditFull.vue @@ -49,12 +49,14 @@ + @saveOccurrence="prepareAccessForAttachments('occurrence')" + @saveFuture="prepareAccessForAttachments('future')" + @saveSeries="prepareAccessForAttachments('series')" />
@@ -75,24 +77,29 @@ {{ $t('calendar', 'Duplicate') }} - + {{ $t('calendar', 'Delete') }} - + {{ $t('calendar', 'Delete this occurrence') }} - - + - {{ $t('calendar', 'Delete this and all future') }} + {{ $t('calendar', 'Delete this and future occurrences') }} + + + + {{ $t('calendar', 'Delete entire series') }}
@@ -127,13 +134,13 @@ {{ $t('calendar', 'All day') }} - + + :isEditingBaseInstance="isEditingBaseInstance" + :isEditingExceptionInstance="isEditingExceptionInstance" + @requireFutureUpdate="requireFutureUpdate" />
@@ -163,7 +170,6 @@ @@ -298,7 +304,7 @@ + @click="acceptAttachmentsModal()"> {{ t('calendar', 'Invite') }}
@@ -345,7 +351,6 @@ import { NcActionButton, NcActionLink, NcActions, - NcActionSeparator, NcButton, NcCheckboxRadioSwitch, NcDialog, @@ -422,7 +427,6 @@ export default { IconVideo, HelpCircleIcon, NcActions, - NcActionSeparator, Close, }, @@ -432,7 +436,7 @@ export default { data() { return { - thisAndAllFuture: false, + saveScope: 'occurrence', doNotShare: false, showModal: false, showModalNewAttachments: [], @@ -719,7 +723,7 @@ export default { this.showModal = false this.showModalNewAttachments = [] this.showModalUsers = [] - this.saveEvent(this.thisAndAllFuture) + this.saveEvent(this.saveScope) }, 500) // trigger save event after make each attachment access // 1) if !isPrivate get attachments NOT SHARED and SharedType is empry -> API ADD SHARE @@ -743,8 +747,8 @@ export default { return name.split('/').pop() }, - prepareAccessForAttachments(thisAndAllFuture = false) { - this.thisAndAllFuture = thisAndAllFuture + prepareAccessForAttachments(scope = 'occurrence') { + this.saveScope = scope const newAttachments = this.calendarObjectInstance.attachments.filter((attachment) => { // get only new attachments // TODO get NOT only new attachments =) Maybe we should filter all attachments without share-type, 'cause event can be private and AFTER save owner could add new participant @@ -764,14 +768,14 @@ export default { return false }) } else { - this.saveEvent(thisAndAllFuture) + this.saveEvent(this.saveScope) } }, - saveEvent(thisAndAllFuture = false) { + saveEvent(scope = 'occurrence') { // if there is new attachments and !private, then make modal with users and files/ // maybe check shared access before add file - this.saveAndLeave(thisAndAllFuture) + this.saveAndLeave(scope) this.calendarObjectInstance.attachments = this.calendarObjectInstance.attachments.map((attachment) => { if (attachment.isNew) { delete attachment.isNew diff --git a/src/views/EditSimple.vue b/src/views/EditSimple.vue index fa63dfbf50..2a0247e786 100644 --- a/src/views/EditSimple.vue +++ b/src/views/EditSimple.vue @@ -88,24 +88,30 @@ {{ $t('calendar', 'Duplicate') }} - + {{ $t('calendar', 'Delete') }} - + {{ $t('calendar', 'Delete this occurrence') }} - - + + - {{ $t('calendar', 'Delete this and all future') }} + {{ $t('calendar', 'Delete this and future occurrences') }} + + + + {{ $t('calendar', 'Delete entire series') }} @@ -214,7 +220,6 @@ v-if="isViewedByAttendee && isViewing" class="event-popover__response-buttons" :attendee="userAsAttendee" - :calendarId="calendarId" @close="closeEditorAndSkipAction" />
@@ -229,15 +234,17 @@ } */ - async saveAndView(thisAndAllFuture) { + async saveAndView(scope) { // Transitioning from new to edit routes is not implemented for now if (this.isNew) { - await this.saveAndLeave(thisAndAllFuture) + await this.saveAndLeave(scope) return } this.isViewing = true try { - await this.save(thisAndAllFuture) + await this.save(scope) this.requiresActionOnRouteLeave = false } catch (error) { logger.error('Failed to save event, reverting to edit mode', { error }) diff --git a/tests/javascript/unit/components/InvitationResponseButtons.test.js b/tests/javascript/unit/components/InvitationResponseButtons.test.js new file mode 100644 index 0000000000..abad352e68 --- /dev/null +++ b/tests/javascript/unit/components/InvitationResponseButtons.test.js @@ -0,0 +1,41 @@ +/** + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +import InvitationResponseButtons from '@/components/Editor/InvitationResponseButtons.vue' + +describe('components/Editor/InvitationResponseButtons', () => { + it.each([ + [false, false, null], + [true, false, 'series'], + [true, true, 'occurrence'], + ])('determines the response scope', (isRecurring, isException, expected) => { + const vm = { + calendarObjectInstanceStore: { + calendarObjectInstance: { + eventComponent: { + isPartOfRecurrenceSet: vi.fn().mockReturnValue(isRecurring), + isRecurrenceException: vi.fn().mockReturnValue(isException), + }, + }, + }, + } + + expect(InvitationResponseButtons.computed.responseScope.call(vm)).toBe(expected) + }) + + it.each([ + [null, 'Accept', 'Decline', 'Tentative'], + ['occurrence', 'Accept this occurrence', 'Decline this occurrence', 'Tentative for this occurrence'], + ['series', 'Accept entire series', 'Decline entire series', 'Tentative for entire series'], + ])('labels responses for the selected scope', (responseScope, accept, decline, tentative) => { + const vm = { + responseScope, + t: (app, text) => text, + } + + expect(InvitationResponseButtons.computed.acceptLabel.call(vm)).toBe(accept) + expect(InvitationResponseButtons.computed.declineLabel.call(vm)).toBe(decline) + expect(InvitationResponseButtons.computed.tentativeLabel.call(vm)).toBe(tentative) + }) +}) diff --git a/tests/javascript/unit/components/Repeat.test.js b/tests/javascript/unit/components/Repeat.test.js new file mode 100644 index 0000000000..edfa87a31d --- /dev/null +++ b/tests/javascript/unit/components/Repeat.test.js @@ -0,0 +1,31 @@ +/** + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +import Repeat from '@/components/Editor/Repeat/Repeat.vue' + +describe('components/Editor/Repeat/Repeat', () => { + it.each([ + [false, [['requireFutureUpdate']]], + [true, []], + ])('requires a future update only outside the master item', (isEditingBaseInstance , expectedCalls) => { + const $emit = vi.fn() + const vm = { + $emit, + isEditingBaseInstance , + recurrenceRule: { isUnsupported: false }, + calendarObjectInstanceStore: { + calendarObjectInstance: { + canModifyAllDay: false, + eventComponent: { + canModifyAllDay: vi.fn().mockReturnValue(true), + }, + }, + }, + } + + Repeat.methods.modified.call(vm) + + expect($emit.mock.calls).toEqual(expectedCalls) + }) +}) diff --git a/tests/javascript/unit/components/SaveButtons.test.js b/tests/javascript/unit/components/SaveButtons.test.js new file mode 100644 index 0000000000..0084a16514 --- /dev/null +++ b/tests/javascript/unit/components/SaveButtons.test.js @@ -0,0 +1,57 @@ +/** + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +import SaveButtons from '@/components/Editor/SaveButtons.vue' + +describe('components/Editor/SaveButtons', () => { + /** + * Compute the visible controls for the given props. + * + * @param {object} overrides Props to override + * @return {object} Visibility by control + */ + function getVisibility(overrides = {}) { + const vm = { + isReadOnly: false, + isNew: false, + canUpdateOccurrence: false, + canUpdateFuture: false, + canUpdateSeries: false, + ...overrides, + } + vm.allowedUpdateScopeCount = SaveButtons.computed.allowedUpdateScopeCount.call(vm) + + return { + save: SaveButtons.computed.showSaveButton.call(vm), + update: SaveButtons.computed.showUpdateButton.call(vm), + future: SaveButtons.computed.showUpdateFutureButton.call(vm), + series: SaveButtons.computed.showUpdateSeriesButton.call(vm), + menu: SaveButtons.computed.showUpdateMenu.call(vm), + } + } + + it.each([ + [{ isNew: true, canUpdateOccurrence: true }, { save: true, update: false, future: false, series: false, menu: false }], + [{ canUpdateOccurrence: true }, { save: false, update: true, future: false, series: false, menu: false }], + [{ canUpdateFuture: true }, { save: false, update: false, future: true, series: false, menu: false }], + [{ canUpdateSeries: true }, { save: false, update: false, future: false, series: true, menu: false }], + [{ canUpdateOccurrence: true, canUpdateFuture: true, canUpdateSeries: true }, { save: false, update: false, future: false, series: false, menu: true }], + [{ isReadOnly: true, canUpdateOccurrence: true }, { save: false, update: false, future: false, series: false, menu: false }], + ])('shows the controls for the allowed update scopes', (props, expected) => { + expect(getVisibility(props)).toEqual(expected) + }) + + it.each([ + ['saveOccurrence', 'saveOccurrence'], + ['saveFuture', 'saveFuture'], + ['saveSeries', 'saveSeries'], + ['showMore', 'showMore'], + ])('%s emits %s', (method, event) => { + const $emit = vi.fn() + + SaveButtons.methods[method].call({ $emit }) + + expect($emit).toHaveBeenCalledWith(event) + }) +}) diff --git a/tests/javascript/unit/mixins/EditorMixin.test.js b/tests/javascript/unit/mixins/EditorMixin.test.js index 5886dd07be..0320ff6a12 100644 --- a/tests/javascript/unit/mixins/EditorMixin.test.js +++ b/tests/javascript/unit/mixins/EditorMixin.test.js @@ -2,8 +2,8 @@ * SPDX-FileCopyrightText: 2019 Nextcloud GmbH and Nextcloud contributors * SPDX-License-Identifier: AGPL-3.0-or-later */ -import EditorMixin from '../../../../src/mixins/EditorMixin.js' -import { ViewMode } from '../../../../src/utils/router.js' +import EditorMixin from '@/mixins/EditorMixin.js' +import { ViewMode } from '@/utils/router.js' describe('mixins/EditorMixin test suite', () => { describe('viewMode', () => { @@ -28,6 +28,196 @@ describe('mixins/EditorMixin test suite', () => { }) }) + describe('isRecurringInstance', () => { + it.each([ + [false, false, false], + [true, false, true], + [false, true, true], + ])('returns the recurrence state for generated and exception instances', (canCreateRecurrenceException, isRecurrenceException, expected) => { + expect(EditorMixin.computed.isRecurringInstance.call({ + canCreateRecurrenceException, + isRecurrenceException, + })).toBe(expected) + }) + }) + + describe('canDelete', () => { + it.each([ + [{ calendarObject: null }, 'occurrence', false], + [{ calendarObject: { existsOnServer: false } }, 'occurrence', false], + [{ isReadOnly: true }, 'occurrence', false], + [{ isLoading: true }, 'occurrence', false], + [{ isRecurringInstance: false }, 'occurrence', true], + [{ isRecurringInstance: false }, 'series', false], + [{ isRecurringInstance: true }, 'occurrence', true], + [{ isRecurringInstance: true }, 'future', true], + [{ isRecurringInstance: true }, 'series', true], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'occurrence', false], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'future', false], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'series', true], + [{ isRecurringInstance: true, isRecurrenceException: true, isViewedByAttendee: true }, 'occurrence', true], + [{ isRecurringInstance: true, isRecurrenceException: true, isViewedByAttendee: true }, 'future', false], + ])('restricts deletion by availability, recurrence, and attendee state', (overrides, scope, expected) => { + const vm = { + calendarObject: { existsOnServer: true }, + isReadOnly: false, + isLoading: false, + isRecurringInstance: false, + isRecurrenceException: false, + isViewedByAttendee: false, + ...overrides, + } + expect(EditorMixin.methods.canDelete.call(vm, scope)).toBe(expected) + }) + }) + + describe('delete', () => { + it('does not execute a disallowed deletion mode', async () => { + const deleteCalendarObjectInstance = vi.fn() + const vm = { + calendarObject: {}, + canDelete: vi.fn().mockReturnValue(false), + calendarObjectInstanceStore: { deleteCalendarObjectInstance }, + isLoading: false, + } + + await EditorMixin.methods.delete.call(vm, 'occurrence') + + expect(deleteCalendarObjectInstance).not.toHaveBeenCalled() + expect(vm.isLoading).toBe(false) + }) + + it('executes an allowed deletion mode', async () => { + const deleteCalendarObjectInstance = vi.fn().mockResolvedValue() + const vm = { + calendarObject: {}, + canDelete: vi.fn().mockReturnValue(true), + calendarObjectInstanceStore: { deleteCalendarObjectInstance }, + isLoading: false, + } + + await EditorMixin.methods.delete.call(vm, 'series') + + expect(deleteCalendarObjectInstance).toHaveBeenCalledWith({ scope: 'series' }) + expect(vm.isLoading).toBe(false) + }) + }) + + describe('canUpdate', () => { + it.each([ + [{ calendarObject: null }, 'occurrence', false], + [{ calendarObject: { existsOnServer: false } }, 'occurrence', false], + [{ isReadOnly: true }, 'occurrence', false], + [{ isLoading: true }, 'occurrence', false], + [{ isNew: true }, 'occurrence', true], + [{ isNew: true }, 'series', false], + [{ requiresFutureUpdate: true }, 'occurrence', false], + [{ requiresFutureUpdate: true }, 'future', true], + [{ isRecurringInstance: false }, 'occurrence', true], + [{ isRecurringInstance: false }, 'series', false], + [{ isRecurringInstance: true }, 'occurrence', true], + [{ isRecurringInstance: true }, 'future', true], + [{ isRecurringInstance: true }, 'series', true], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'occurrence', false], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'future', false], + [{ isRecurringInstance: true, isViewedByAttendee: true }, 'series', true], + [{ isRecurringInstance: true, isRecurrenceException: true, isViewedByAttendee: true }, 'occurrence', true], + [{ isRecurringInstance: true, isRecurrenceException: true, isViewedByAttendee: true }, 'future', false], + ])('restricts updates by availability, recurrence, and attendee state', (overrides, scope, expected) => { + const vm = { + calendarObject: { existsOnServer: true }, + isReadOnly: false, + isLoading: false, + isNew: false, + requiresFutureUpdate: false, + isRecurringInstance: false, + isRecurrenceException: false, + isViewedByAttendee: false, + ...overrides, + } + expect(EditorMixin.methods.canUpdate.call(vm, scope)).toBe(expected) + }) + }) + + describe('requireFutureUpdate', () => { + it('marks future updates as required', () => { + const vm = { requiresFutureUpdate: false } + + EditorMixin.methods.requireFutureUpdate.call(vm) + + expect(vm.requiresFutureUpdate).toBe(true) + }) + }) + + describe('created', () => { + it('marks a new event as its own master item', async () => { + const vm = { + isWidget: false, + isLoading: true, + isEditingBaseInstance : false, + calendarId: null, + $route: { name: 'NewFullView', params: { allDay: '0', dtstart: '1000', dtend: '2000' } }, + settingsStore: { getResolvedTimezone: 'UTC' }, + calendarObjectInstanceStore: { + getCalendarObjectInstanceForNewEvent: vi.fn().mockResolvedValue(), + }, + loadingCalendars: vi.fn().mockResolvedValue(), + addDelegatorAsAttendeeIfNeeded: vi.fn(), + calendarObject: { calendarId: 'calendar-1' }, + selectedCalendar: {}, + } + + await EditorMixin.created.call(vm) + + // Without this, a recurrence-rule change on a brand new event is + // wrongly treated as requiring a future-only update, which a new + // event can never satisfy, silently blocking the save. + expect(vm.isEditingBaseInstance ).toBe(true) + }) + }) + + describe('save', () => { + it('does not execute a disallowed update scope', async () => { + const saveCalendarObjectInstance = vi.fn() + const vm = { + calendarObject: {}, + requiresFutureUpdate: false, + canUpdate: vi.fn().mockReturnValue(false), + calendarObjectInstanceStore: { saveCalendarObjectInstance }, + isLoading: false, + isSaving: false, + } + + await EditorMixin.methods.save.call(vm, 'occurrence') + + expect(saveCalendarObjectInstance).not.toHaveBeenCalled() + expect(vm.isLoading).toBe(false) + expect(vm.isSaving).toBe(false) + }) + + it('executes an allowed update scope', async () => { + const saveCalendarObjectInstance = vi.fn().mockResolvedValue() + const vm = { + calendarObject: {}, + calendarId: 'calendar-1', + requiresFutureUpdate: false, + canUpdate: vi.fn().mockReturnValue(true), + calendarObjectInstanceStore: { saveCalendarObjectInstance }, + isLoading: false, + isSaving: false, + } + + await EditorMixin.methods.save.call(vm, 'series') + + expect(saveCalendarObjectInstance).toHaveBeenCalledWith({ + scope: 'series', + calendarId: 'calendar-1', + }) + expect(vm.isLoading).toBe(false) + expect(vm.isSaving).toBe(false) + }) + }) + describe('duplicateEvent', () => { it('does nothing when duplication is not allowed in the current view (e.g. public/embedded/widget)', async () => { const duplicateCalendarObjectInstance = vi.fn() diff --git a/tests/javascript/unit/models/event.test.js b/tests/javascript/unit/models/event.test.js index f2f830c3ee..4fa5e65506 100644 --- a/tests/javascript/unit/models/event.test.js +++ b/tests/javascript/unit/models/event.test.js @@ -55,7 +55,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: false, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -98,7 +97,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: false, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -149,7 +147,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -209,7 +206,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [ 'ATTENDEE1', @@ -283,7 +279,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -341,7 +336,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -398,7 +392,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -458,7 +451,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -515,7 +507,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -569,7 +560,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -623,7 +613,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: true, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -681,7 +670,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: false, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: true, attendees: [], organizer: null, @@ -738,7 +726,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: false, isRecurrenceException: true, - forceThisAndAllFuture: false, canCreateRecurrenceException: false, attendees: [], organizer: null, @@ -793,7 +780,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: true, isMasterItem: false, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: true, attendees: [], organizer: null, @@ -851,7 +837,6 @@ describe('Test suite: Event model (models/event.js)', () => { hasMultipleRRules: false, isMasterItem: false, isRecurrenceException: false, - forceThisAndAllFuture: false, canCreateRecurrenceException: true, attendees: [], organizer: null, diff --git a/tests/javascript/unit/store/calendarObjectInstance.test.ts b/tests/javascript/unit/store/calendarObjectInstance.test.ts index 33b22e8d1f..1c71e168de 100644 --- a/tests/javascript/unit/store/calendarObjectInstance.test.ts +++ b/tests/javascript/unit/store/calendarObjectInstance.test.ts @@ -58,9 +58,7 @@ describe('store/calendarObjectInstance test suite', () => { await store.duplicateCalendarObjectInstance({ calendarId: 'writable-calendar' }) - expect(calendarObjectsStore.createNewEvent).toHaveBeenCalledWith( - expect.objectContaining({ calendarId: 'writable-calendar' }), - ) + expect(calendarObjectsStore.createNewEvent).toHaveBeenCalledWith(expect.objectContaining({ calendarId: 'writable-calendar' })) }) it('marks the duplicated event as a new, unsaved calendar-object', async () => { @@ -138,4 +136,143 @@ describe('store/calendarObjectInstance test suite', () => { expect(calendarObjectInstance.alarms).not.toContain(alarm) }) }) + + describe('saveAttendeeParticipationResponse', () => { + it('updates the recurring master when responding to a generated occurrence', async () => { + const store = useCalendarObjectInstanceStore() + const calendarObjectsStore = useCalendarObjectsStore() + const masterAttendee = { + email: 'attendee@example.com', + participationStatus: 'NEEDS-ACTION', + } + const masterComponent = { + name: 'VEVENT', + hasProperty: vi.fn().mockReturnValue(false), + getAttendeeIterator: vi.fn().mockReturnValue([masterAttendee]), + } + const occurrenceAttendee = { + email: 'ATTENDEE@example.com', + participationStatus: 'NEEDS-ACTION', + } + const eventComponent = { + name: 'VEVENT', + isRecurrenceException: vi.fn().mockReturnValue(false), + } + const attendee = { + attendeeProperty: occurrenceAttendee, + participationStatus: 'NEEDS-ACTION', + } + const calendarObject = { + calendarComponent: { + getComponentIterator: vi.fn().mockReturnValue([masterComponent]), + }, + } + store.calendarObject = calendarObject + store.calendarObjectInstance = { eventComponent } + vi.spyOn(calendarObjectsStore, 'updateCalendarObject').mockResolvedValue() + + await store.saveAttendeeParticipationResponse({ + attendee, + participationStatus: 'ACCEPTED', + }) + + expect(masterAttendee.participationStatus).toBe('ACCEPTED') + expect(occurrenceAttendee.participationStatus).toBe('NEEDS-ACTION') + expect(attendee.participationStatus).toBe('ACCEPTED') + expect(calendarObjectsStore.updateCalendarObject).toHaveBeenCalledWith({ calendarObject }) + }) + + it('updates an existing recurrence exception without changing the master', async () => { + const store = useCalendarObjectInstanceStore() + const calendarObjectsStore = useCalendarObjectsStore() + const masterAttendee = { + email: 'attendee@example.com', + participationStatus: 'ACCEPTED', + } + const exceptionAttendee = { + email: 'attendee@example.com', + participationStatus: 'NEEDS-ACTION', + } + const eventComponent = { + name: 'VEVENT', + isRecurrenceException: vi.fn().mockReturnValue(true), + } + const attendee = { + attendeeProperty: exceptionAttendee, + participationStatus: 'NEEDS-ACTION', + } + const calendarObject = { + calendarComponent: { + getComponentIterator: vi.fn().mockReturnValue([{ + name: 'VEVENT', + getAttendeeIterator: vi.fn().mockReturnValue([masterAttendee]), + }]), + }, + } + store.calendarObject = calendarObject + store.calendarObjectInstance = { eventComponent } + vi.spyOn(calendarObjectsStore, 'updateCalendarObject').mockResolvedValue() + + await store.saveAttendeeParticipationResponse({ + attendee, + participationStatus: 'DECLINED', + }) + + expect(exceptionAttendee.participationStatus).toBe('DECLINED') + expect(masterAttendee.participationStatus).toBe('ACCEPTED') + expect(attendee.participationStatus).toBe('DECLINED') + expect(calendarObject.calendarComponent.getComponentIterator).not.toHaveBeenCalled() + expect(calendarObjectsStore.updateCalendarObject).toHaveBeenCalledWith({ calendarObject }) + }) + }) + + describe('saveCalendarObjectInstance', () => { + it('updates the recurring base component when saving the series from an exception', async () => { + const store = useCalendarObjectInstanceStore() + const calendarObjectsStore = useCalendarObjectsStore() + const baseProperty = { + name: 'SUMMARY', + } + const exceptionPropertyClone = {} + const exceptionProperty = { + name: 'SUMMARY', + clone: vi.fn().mockReturnValue(exceptionPropertyClone), + } + const baseComponent = { + name: 'VEVENT', + hasProperty: vi.fn().mockReturnValue(false), + getPropertyIterator: vi.fn().mockReturnValue([baseProperty]), + deleteAllProperties: vi.fn(), + addProperty: vi.fn(), + deleteAllComponents: vi.fn(), + addComponent: vi.fn(), + } + const exceptionComponent = { + name: 'VEVENT', + primaryItem: {}, + isDirty: vi.fn().mockReturnValue(true), + isPartOfRecurrenceSet: vi.fn().mockReturnValue(true), + getPropertyIterator: vi.fn().mockReturnValue([exceptionProperty]), + getAlarmIterator: vi.fn().mockReturnValue([]), + } + const calendarObject = { + calendarId: 'calendar-1', + calendarComponent: { + getComponentIterator: vi.fn().mockReturnValue([baseComponent, exceptionComponent]), + }, + } + store.calendarObject = calendarObject + store.calendarObjectInstance = { eventComponent: exceptionComponent } + vi.spyOn(calendarObjectsStore, 'updateCalendarObject').mockResolvedValue() + + await store.saveCalendarObjectInstance({ + scope: 'series', + calendarId: 'calendar-1', + }) + + expect(baseComponent.deleteAllProperties).toHaveBeenCalledWith('SUMMARY') + expect(baseComponent.addProperty).toHaveBeenCalledWith(exceptionPropertyClone) + expect(calendarObjectsStore.updateCalendarObject).toHaveBeenCalledWith({ calendarObject }) + }) + }) }) From d447b1a57e8d8fa8ba04ba5e3e581d3d8997dd43 Mon Sep 17 00:00:00 2001 From: SebastianKrupinski Date: Fri, 28 Aug 2026 10:31:39 -0400 Subject: [PATCH 2/4] fixup! fix: update, delete, accept, devline all occurrences Signed-off-by: SebastianKrupinski --- src/store/calendarObjectInstance.js | 21 +++++++++++++++------ src/views/EditFull.vue | 4 ++-- src/views/EditSimple.vue | 3 --- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/store/calendarObjectInstance.js b/src/store/calendarObjectInstance.js index 53a94c594f..49bcd88e18 100644 --- a/src/store/calendarObjectInstance.js +++ b/src/store/calendarObjectInstance.js @@ -1449,7 +1449,7 @@ export default defineStore('calendarObjectInstance', { updateAlarms(eventComponent) - if (eventComponent.isDirty() && eventComponent.isPartOfRecurrenceSet() && scope === 'series' && isForkedItem) { + if (eventComponent.isDirty() && eventComponent.isPartOfRecurrenceSet() && scope === 'series') { // Find the master component (without RECURRENCE-ID) let baseComponent = null for (const component of calendarObject.calendarComponent.getComponentIterator()) { @@ -1459,8 +1459,10 @@ export default defineStore('calendarObjectInstance', { } } - if (baseComponent) { - // construct list of properties to clone + if (!baseComponent) { + logger.error('Could not find master component to save series-wide changes to') + } else { + // construct list of properties to clone as we might be editing a instance or fork not the base component const propertyNames = [] for (const property of baseComponent.getPropertyIterator()) { if (property.name === 'UID' || property.name === 'RECURRENCE-ID' || property.name === 'DTSTART' || property.name === 'DTEND') { @@ -1476,14 +1478,21 @@ export default defineStore('calendarObjectInstance', { } baseComponent.addProperty(property.clone()) } - // clone alarms + // DTSTART and DTEND need to be cloned separately so that internal logic of ical.js + // can adjust all the recurrence rules and exceptions accordingly + baseComponent.startDate = eventComponent.startDate.clone() + baseComponent.endDate = eventComponent.endDate.clone() + // Only VALARM is copied here because it's the only sub-component the + // editor currently lets users change; other sub-components (e.g. + // PARTICIPANT, VLOCATION, VRESOURCE) that another client may have set + // are left untouched on baseComponent. baseComponent.deleteAllComponents('VALARM') for (const alarm of eventComponent.getAlarmIterator()) { baseComponent.addComponent(alarm.clone()) } - } - await calendarObjectsStore.updateCalendarObject({ calendarObject }) + await calendarObjectsStore.updateCalendarObject({ calendarObject }) + } } if (eventComponent.isDirty() && scope !== 'series') { diff --git a/src/views/EditFull.vue b/src/views/EditFull.vue index 2a6181b927..b516a88401 100644 --- a/src/views/EditFull.vue +++ b/src/views/EditFull.vue @@ -747,7 +747,7 @@ export default { return name.split('/').pop() }, - prepareAccessForAttachments(scope = 'occurrence') { + prepareAccessForAttachments(scope) { this.saveScope = scope const newAttachments = this.calendarObjectInstance.attachments.filter((attachment) => { // get only new attachments @@ -772,7 +772,7 @@ export default { } }, - saveEvent(scope = 'occurrence') { + saveEvent(scope) { // if there is new attachments and !private, then make modal with users and files/ // maybe check shared access before add file this.saveAndLeave(scope) diff --git a/src/views/EditSimple.vue b/src/views/EditSimple.vue index 2a0247e786..f4763fb6e6 100644 --- a/src/views/EditSimple.vue +++ b/src/views/EditSimple.vue @@ -100,7 +100,6 @@ {{ $t('calendar', 'Delete this occurrence') }} -