feat: add readonly delegation

Signed-off-by: Grigory Vodyanov <scratchx@gmx.com>

Author: GVodyanov

src/components/AppNavigation/Settings/SettingsDelegationSection.vue

@@ -22,8 +22,10 @@
 					v-for="delegate in delegationStore.delegates"
 					:key="delegate.url"
 					:name="delegate.displayname || delegate.principalId"
-					:subname="delegate.emailAddress"
 					:compact="true">
+					<template #subname>
+						{{ delegateSubname(delegate) }}
+					</template>
 					<template #actions>
 						<NcActionButton
 							:aria-label="t('calendar', 'Revoke access')"
@@ -98,18 +100,24 @@
 					</template>
 				</NcSelect>
 				<p class="delegation-add__description">
-					{{ t('calendar', 'They will be able to manage your calendar events and invitations on your behalf.') }}
+					{{ t('calendar', 'Choose whether they can view and edit events, or only view them.') }}
 				</p>
 			</div>
 			<template #actions>
 				<NcButton variant="secondary" @click="showAddDelegate = false">
 					{{ t('calendar', 'Cancel') }}
 				</NcButton>
+				<NcButton
+					variant="secondary"
+					:disabled="!selectedUser || addLoading"
+					@click="confirmAddDelegate('read')">
+					{{ t('calendar', 'Add as viewer') }}
+				</NcButton>
 				<NcButton
 					variant="primary"
 					:disabled="!selectedUser || addLoading"
-					@click="confirmAddDelegate">
-					{{ t('calendar', 'Add') }}
+					@click="confirmAddDelegate('write')">
+					{{ t('calendar', 'Add as editor') }}
 				</NcButton>
 			</template>
 		</NcDialog>
@@ -229,6 +237,23 @@ export default {
 	},
 
 	methods: {
+		/**
+		 * Returns a descriptive subname for a delegate list item
+		 * showing their permission level and optionally their email.
+		 *
+		 * @param {object} delegate The delegate principal object
+		 * @return {string}
+		 */
+		delegateSubname(delegate) {
+			const permissionLabel = delegate.permission === 'read'
+				? this.t('calendar', 'Viewer')
+				: this.t('calendar', 'Editor')
+			if (delegate.emailAddress) {
+				return `${permissionLabel} · ${delegate.emailAddress}`
+			}
+			return permissionLabel
+		},
+
 		/**
 		 * Open the revoke confirmation dialog for a specific delegate.
 		 *
@@ -289,17 +314,22 @@ export default {
 
 		/**
 		 * Execute the add-delegate operation.
+		 *
+		 * @param {'write'|'read'} permission The permission level to grant
 		 */
-		async confirmAddDelegate() {
+		async confirmAddDelegate(permission) {
 			if (!this.selectedUser) {
 				return
 			}
 			this.addLoading = true
 			const user = this.selectedUser
 			this.showAddDelegate = false
 			try {
-				await this.delegationStore.addDelegate({ principalUrl: user.url })
-				showSuccess(this.t('calendar', '{name} can now act on your behalf.', { name: user.displayname || user.principalId }))
+				await this.delegationStore.addDelegate({ principalUrl: user.url, permission })
+				const label = permission === 'read'
+					? this.t('calendar', '{name} can now view your calendars.', { name: user.displayname || user.principalId })
+					: this.t('calendar', '{name} can now act on your behalf.', { name: user.displayname || user.principalId })
+				showSuccess(label)
 			} catch (error) {
 				logger.error('Failed to add delegate', { error })
 				showError(this.t('calendar', 'Could not add delegate.'))
@@ -352,7 +382,7 @@ export default {
 						if (currentUser && result.principalUrl === currentUser.url) {
 							return false
 						}
-						// Exclude already-existing delegates
+						// Exclude already-existing delegates (both editors and viewers)
 						if (existingDelegateUrls.includes(result.principalUrl)) {
 							return false
 						}

src/store/delegation.js

@@ -16,21 +16,20 @@ export default defineStore('delegation', {
 	state: () => {
 		return {
 			/**
-			 * List of principal objects that the current user has delegated to
-			 * (members of the current user's calendar-proxy-write group).
+			 * List of principal objects that the current user has delegated to.
+			 * Each entry has the principal fields plus a `permission` field ('write'|'read').
 			 *
 			 * @type {object[]}
 			 */
 			delegates: [],
 
 			/**
-			 * Principal URLs of users who have granted the current user proxy access.
-			 * Stored as full absolute principal URLs so calendar-home discovery can
-			 * be performed without reconstructing paths from user IDs.
+			 * Users who have granted the current user proxy access, with permission level.
+			 * Each entry: { principalUrl: string, permission: 'write'|'read' }
 			 *
-			 * @type {string[]}
+			 * @type {Array<{principalUrl: string, permission: 'write'|'read'}>}
 			 */
-			delegatorPrincipalUrls: [],
+			delegators: [],
 		}
 	},
 
@@ -41,13 +40,13 @@ export default defineStore('delegation', {
 		 * @param {object} state The store state
 		 * @return {boolean}
 		 */
-		hasDelegatedCalendars: (state) => state.delegatorPrincipalUrls.length > 0,
+		hasDelegatedCalendars: (state) => state.delegators.length > 0,
 	},
 
 	actions: {
 		/**
-		 * Fetch the current user's delegates (members of their calendar-proxy-write group)
-		 * and resolve their principal details.
+		 * Fetch the current user's delegates (members of their calendar-proxy-write
+		 * and calendar-proxy-read groups) and resolve their principal details.
 		 *
 		 * @return {Promise<void>}
 		 */
@@ -58,33 +57,53 @@ export default defineStore('delegation', {
 				return
 			}
 
-			const proxyWriteGroupUrl = currentUser.url.replace(/\/?$/, '') + '/calendar-proxy-write'
+			const baseUrl = currentUser.url.replace(/\/?$/, '')
+			const proxyWriteGroupUrl = baseUrl + '/calendar-proxy-write'
+			const proxyReadGroupUrl = baseUrl + '/calendar-proxy-read'
 
-			let memberUrls
+			let writeUrls = []
+			let readUrls = []
 			try {
-				memberUrls = await getClient().getDelegateUrls(proxyWriteGroupUrl)
+				[writeUrls, readUrls] = await Promise.all([
+					getClient().getDelegateUrls(proxyWriteGroupUrl),
+					getClient().getDelegateUrls(proxyReadGroupUrl),
+				])
 			} catch (error) {
 				logger.error('Could not fetch delegate URLs', { error })
 				return
 			}
 
 			const delegates = []
-			for (const url of memberUrls) {
+
+			for (const url of writeUrls) {
 				try {
 					const dav = await findPrincipalByUrl(url)
 					if (dav) {
-						delegates.push(mapDavToPrincipal(dav))
+						delegates.push({ ...mapDavToPrincipal(dav), permission: 'write' })
 					}
 				} catch (error) {
-					logger.error('Could not resolve delegate principal', { url, error })
+					logger.error('Could not resolve write delegate principal', { url, error })
 				}
 			}
+
+			for (const url of readUrls) {
+				try {
+					const dav = await findPrincipalByUrl(url)
+					if (dav) {
+						delegates.push({ ...mapDavToPrincipal(dav), permission: 'read' })
+					}
+				} catch (error) {
+					logger.error('Could not resolve read delegate principal', { url, error })
+				}
+			}
+
 			this.delegates = delegates
 			logger.debug('Fetched delegates', { delegates: this.delegates })
 		},
 
 		/**
-		 * Fetch the principal URLs of users who have granted the current user proxy access.
+		 * Fetch the principal URLs and permission level of users who have granted
+		 * the current user proxy access (both read and write).
 		 *
 		 * @return {Promise<void>}
 		 */
@@ -96,34 +115,38 @@ export default defineStore('delegation', {
 			}
 
 			try {
-				this.delegatorPrincipalUrls = await getClient().getDelegatorPrincipalUrls(currentUser.url)
-				logger.debug('Fetched delegators', { delegatorPrincipalUrls: this.delegatorPrincipalUrls })
+				this.delegators = await getClient().getDelegatorsWithPermission(currentUser.url)
+				logger.debug('Fetched delegators', { delegators: this.delegators })
 			} catch (error) {
-				logger.error('Could not fetch delegator principal URLs', { error })
+				logger.error('Could not fetch delegator information', { error })
 			}
 		},
 
 		/**
-		 * Add a user as a delegate (add them to the current user's calendar-proxy-write group).
+		 * Add a user as a delegate with the given permission level.
 		 *
 		 * @param {object} data The destructuring object
 		 * @param {string} data.principalUrl Absolute URL of the principal to add
+		 * @param {'write'|'read'} data.permission The permission level to grant
 		 * @return {Promise<void>}
 		 */
-		async addDelegate({ principalUrl }) {
+		async addDelegate({ principalUrl, permission = 'write' }) {
 			const principalsStore = usePrincipalsStore()
 			const currentUser = principalsStore.getCurrentUserPrincipal
 			if (!currentUser?.url) {
 				return
 			}
 
-			const proxyWriteGroupUrl = currentUser.url.replace(/\/?$/, '') + '/calendar-proxy-write'
-			await getClient().addDelegate(proxyWriteGroupUrl, principalUrl)
+			const baseUrl = currentUser.url.replace(/\/?$/, '')
+			const proxyGroupUrl = permission === 'read'
+				? baseUrl + '/calendar-proxy-read'
+				: baseUrl + '/calendar-proxy-write'
+			await getClient().addDelegate(proxyGroupUrl, principalUrl)
 			await this.fetchDelegates()
 		},
 
 		/**
-		 * Remove a delegate (remove them from the current user's calendar-proxy-write group).
+		 * Remove a delegate from whichever proxy group(s) they are in.
 		 *
 		 * @param {object} data The destructuring object
 		 * @param {string} data.principalUrl Absolute URL of the principal to remove
@@ -136,8 +159,15 @@ export default defineStore('delegation', {
 				return
 			}
 
-			const proxyWriteGroupUrl = currentUser.url.replace(/\/?$/, '') + '/calendar-proxy-write'
-			await getClient().removeDelegate(proxyWriteGroupUrl, principalUrl)
+			const baseUrl = currentUser.url.replace(/\/?$/, '')
+			// Find the delegate's current permission so we remove from the right group.
+			const existing = this.delegates.find((d) => d.url === principalUrl)
+			const permission = existing?.permission ?? 'write'
+
+			const proxyGroupUrl = permission === 'read'
+				? baseUrl + '/calendar-proxy-read'
+				: baseUrl + '/calendar-proxy-write'
+			await getClient().removeDelegate(proxyGroupUrl, principalUrl)
 			this.delegates = this.delegates.filter((d) => d.url !== principalUrl)
 		},
 
@@ -147,24 +177,21 @@ export default defineStore('delegation', {
 		 * The calendars are tagged with isDelegated=true so CalendarList can show them
 		 * in their own section.
 		 *
-		 * Calendar home URLs are discovered via CalDAV PROPFIND on each delegator's
-		 * principal (RFC 4791 §6.2.1) rather than being constructed from user IDs,
-		 * which ensures correctness regardless of server path conventions.
+		 * Read-only delegators' calendars are additionally marked readOnly=true so they
+		 * are excluded from the calendar picker (which only lists writable calendars).
 		 *
 		 * @return {Promise<void>}
 		 */
 		async fetchDelegatedCalendars() {
-			if (!this.delegatorPrincipalUrls.length) {
+			if (!this.delegators.length) {
 				return
 			}
 
 			const principalsStore = usePrincipalsStore()
 			const calendarsStore = useCalendarsStore()
 			const currentUser = principalsStore.getCurrentUserPrincipal
 
-			for (const delegatorPrincipalUrl of this.delegatorPrincipalUrls) {
-				// Discover the delegator's calendar home URL via CalDAV principal PROPFIND.
-				// This follows RFC 4791 §6.2.1 and avoids hard-coding any URL path convention.
+			for (const { principalUrl: delegatorPrincipalUrl, permission } of this.delegators) {
 				const calendarHomeUrl = await getClient().getCalendarHomeUrlForPrincipal(delegatorPrincipalUrl)
 				if (!calendarHomeUrl) {
 					logger.warn('Could not determine calendar home URL for delegator', { delegatorPrincipalUrl })
@@ -176,16 +203,20 @@ export default defineStore('delegation', {
 					const rawCalendars = await findCalendarsAtUrl(calendarHomeUrl)
 					const mappedCalendars = rawCalendars
 						.map((cal) => mapDavCollectionToCalendar(cal, currentUser))
-						.map((cal) => ({ ...cal, isDelegated: true }))
+						.map((cal) => ({
+							...cal,
+							isDelegated: true,
+							// Read-only proxy access: prevent editing and hide from calendar picker
+							...(permission === 'read' ? { readOnly: true } : {}),
+						}))
 
 					for (const calendar of mappedCalendars) {
-						// Only add if not already present
 						if (!calendarsStore.getCalendarById(calendar.id)) {
 							calendarsStore.addCalendarMutation({ calendar })
 						}
 					}
 
-					logger.debug('Fetched delegated calendars from', { calendarHomeUrl, count: mappedCalendars.length })
+					logger.debug('Fetched delegated calendars from', { calendarHomeUrl, permission, count: mappedCalendars.length })
 				} catch (error) {
 					logger.error('Could not fetch calendars for delegator', { delegatorPrincipalUrl, error })
 					showError(t('calendar', 'Could not load delegated calendars. Make sure the server supports calendar delegation.'))