# Contrôle des autorisations - Human documentation: [https://docs.univer.ai/fr-FR/guides/sheets/features/core/permission](https://docs.univer.ai/fr-FR/guides/sheets/features/core/permission) - Agent Markdown: [https://docs.univer.ai/fr-FR/guides/sheets/features/core/permission.md](https://docs.univer.ai/fr-FR/guides/sheets/features/core/permission.md) - Requested language: `fr-FR` - Content language: `fr-FR` - Documentation version: `1.2.0` - Source: [sheets/features/core/permission.fr-FR.mdx](https://github.com/dream-num/documentation/blob/dev/content/guides/sheets/features/core/permission.fr-FR.mdx) --- Univer propose un système de contrôle des autorisations qui permet de limiter les opérations des utilisateurs sur les classeurs, les feuilles de calcul et les plages. Lorsqu’un utilisateur tente une opération sans disposer de l’autorisation requise, son exécution est interrompue et l’utilisateur en est informé. Vous pouvez, par exemple, protéger une plage afin de déterminer si les collaborateurs peuvent la modifier, l’afficher, la copier ou la filtrer. > [!WARNING] > Le service doit persister les règles et les changements de collaborateurs, retourner les droits de l’utilisateur actuel et propager les échecs de requête. Des listes vides simulées ne constituent pas une persistance. En collaboration, le backend doit vérifier séparément les droits de lecture, JOIN et modification ; voir [Identité et autorisation](https://docs.univer.ai/fr-FR/server/collaboration/identity-and-authorization.md). La protection de l’interface et le masquage des ombres ne remplacent pas l’autorisation serveur. > > [Intégration du service d’autorisation](#authorization-service) > Interactive example: [Open the playground](/playground/sheets/permission) Accédez à la section correspondant à votre tâche. Opérations de base, exemples avancés, configuration et dépannage restent sur cette page ; les contrats API complets sont maintenus dans Reference. * [Tâches courantes](#permission-tasks) * [Configuration de l’interface des permissions](#permission-ui) * [Intégration du service d’autorisation](#permission-integration) * [Reference](#reference) ## Concepts fondamentaux * Portée : les autorisations s’appliquent à trois niveaux : classeur, feuille de calcul et plage. * Points d’autorisation : chaque fonctionnalité correspond à un point d’autorisation. La modification d’un point détermine si la fonctionnalité est disponible. * Règles de protection : avant de définir les points d’autorisation d’une feuille de calcul ou d’une plage, vous devez créer une règle de protection. > [!INFO] > Les permissions locales non persistantes se modifient via les points de permission. Pour la persistance, consultez [Intégration du service d’autorisation](#authorization-service) > > Dans un contexte d’édition collaborative, la mise à jour d’un point d’autorisation synchronise l’état du serveur : > > * `false` : le point d’autorisation exige au minimum le rôle `owner` > * `true` : le point d’autorisation exige au minimum le rôle `reader` ## Exemple de base Avant d’utiliser les exemples `allowedUsers`, remplacez `user1` et `user2` par les identifiants réels de collaborateurs retournés par votre service d’autorisation. Les méthodes les plus courantes de configuration des autorisations sont présentées ci-dessous pour les trois niveaux : classeur, feuille de calcul et plage. ### Exemple de code pour les autorisations d’un classeur Les autorisations au niveau du classeur peuvent être définies directement avec l’[Facade API](https://docs.univer.ai/fr-FR/guides/sheets/getting-started/facade.md). L’exemple suivant désactive la modification de l’ensemble du classeur. Pour les autres fonctionnalités, remplacez le point d’autorisation en conséquence (consultez la [liste des points d’autorisation du classeur](#workbook-point)) : ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const workbookPermission = fWorkbook.getWorkbookPermission() // Set the workbook to be non-editable await workbookPermission.setPoint(univerAPI.Enum.WorkbookPermissionPoint.Edit, false) ``` À retenir : * Les points d’autorisation d’un classeur peuvent être définis directement, sans créer de règle de protection. ### Exemple de code pour les autorisations d’une feuille de calcul Les autorisations des feuilles de calcul et des plages peuvent être définies avec l’API Facade ou avec des commandes. L’exemple suivant montre comment configurer l’autorisation de modification d’une feuille de calcul. Pour les autres fonctionnalités, remplacez le point d’autorisation en conséquence (consultez la [liste des points d’autorisation des feuilles de calcul](#worksheet-point)) : ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const fWorksheet = fWorkbook.getActiveSheet() const worksheetPermission = fWorksheet.getWorksheetPermission() // Create worksheet protection, allow specified users to edit const permissionId = await worksheetPermission.protect({ allowedUsers: ['user1', 'user2'], name: 'My Worksheet Protection', }) // To set permission points, you must first protect the worksheet await worksheetPermission.setPoint(univerAPI.Enum.WorksheetPermissionPoint.Edit, false) ``` #### Supprimer les autorisations d’une feuille de calcul ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const fWorksheet = fWorkbook.getActiveSheet() const worksheetPermission = fWorksheet.getWorksheetPermission() // Remove worksheet protection await worksheetPermission.unprotect() ``` ### Exemple de code pour les autorisations d’une plage personnalisée Les autorisations d’une plage peuvent également être définies par l’API ou par des commandes. Nous prendrons ici l’autorisation de modification d’une plage comme exemple. Pour les autres fonctionnalités, remplacez les points d’autorisation ; consultez la [liste des points d’autorisation des plages](#range-point) pour en savoir plus. ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const fWorksheet = fWorkbook.getActiveSheet() const fRange = fWorksheet.getRange('A1:B2') const rangePermission = fRange.getRangePermission() // Set range protection permission, allow specified users to edit but not allow others to view const rule = await rangePermission.protect({ name: 'My protected range', allowViewByOthers: false, allowedUsers: ['user1', 'user2'], }) console.log(rule) // To set permission points, you must first create a range protection rule. await rule.setPoint(univerAPI.Enum.RangePermissionPoint.Edit, false) await rule.setPoint(univerAPI.Enum.RangePermissionPoint.View, true) ``` #### Supprimer les autorisations de protection d’une plage ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const fWorksheet = fWorkbook.getActiveSheet() const fRange = fWorksheet.getRange('A1:B2') const rangePermission = fRange.getRangePermission() // delete all rules within the range await rangePermission.unprotect() // Or delete specific rules within the range const rules = await rangePermission.listRules() if (rules.length > 0) { await rules[0].remove() } ``` ## Tâches courantes ### Passer un classeur en lecture seule ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const permission = fWorkbook.getWorkbookPermission() await permission.setMode('viewer') console.log(permission.getSnapshot()) ``` ### Gérer les plages protégées ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const fWorksheet = fWorkbook.getActiveSheet() const permission = fWorksheet.getWorksheetPermission() const createdRules = await permission.protectRanges([ { ranges: [fWorksheet.getRange('A1:B2')], options: { name: 'Public area', allowViewByOthers: true }, }, { ranges: [fWorksheet.getRange('C3:D4')], options: { name: 'Private area', allowViewByOthers: false, allowedUsers: ['user1'] }, }, ]) console.log(createdRules) const rules = await permission.listRangeProtectionRules() const firstRule = rules[0] if (firstRule) { await firstRule.updateRanges([fWorksheet.getRange('A1:B3')]) } ``` ### Diagnostiquer les permissions d’une cellule ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const permission = fWorkbook.getActiveSheet().getWorksheetPermission() console.log(permission.debugCellPermission(0, 0)) ``` ## Liste des points d’autorisation Vous pouvez consulter [ici](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) le code source de tous les points d’autorisation. Lorsque les autorisations du classeur se superposent à celles d’une feuille de calcul ou d’une plage, **toutes** les autorisations concernées doivent être définies sur `true` pour que la fonctionnalité soit utilisable. ### Autorisations du classeur | Énumération de l’API | Classe de point d’autorisation correspondante | Description | | --------------------------------------------------------- | --------------------------------------------- | ------------------------------------- | | univerAPI.Enum.WorkbookPermissionPoint.Edit | WorkbookEditablePermission | Peut modifier | | univerAPI.Enum.WorkbookPermissionPoint.View | WorkbookViewPermission | Peut afficher | | univerAPI.Enum.WorkbookPermissionPoint.Print | WorkbookPrintPermission | Peut imprimer | | univerAPI.Enum.WorkbookPermissionPoint.Export | WorkbookExportPermission | Peut exporter | | univerAPI.Enum.WorkbookPermissionPoint.Share | WorkbookSharePermission | Peut partager | | univerAPI.Enum.WorkbookPermissionPoint.CopyContent | WorkbookCopyPermission | Peut copier | | univerAPI.Enum.WorkbookPermissionPoint.DuplicateFile | WorkbookDuplicatePermission | Peut dupliquer | | univerAPI.Enum.WorkbookPermissionPoint.Comment | WorkbookCommentPermission | Peut commenter | | univerAPI.Enum.WorkbookPermissionPoint.ManageCollaborator | WorkbookManageCollaboratorPermission | Peut gérer les collaborateurs | | univerAPI.Enum.WorkbookPermissionPoint.CreateSheet | WorkbookCreateSheetPermission | Peut créer des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.DeleteSheet | WorkbookDeleteSheetPermission | Peut supprimer des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.RenameSheet | WorkbookRenameSheetPermission | Peut renommer des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.MoveSheet | WorkbookMoveSheetPermission | Peut déplacer des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.HideSheet | WorkbookHideSheetPermission | Peut masquer des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.CopySheet | WorkbookCopySheetPermission | Peut copier des feuilles de calcul | | univerAPI.Enum.WorkbookPermissionPoint.ViewHistory | WorkbookViewHistoryPermission | Peut consulter l’historique | | univerAPI.Enum.WorkbookPermissionPoint.RecoverHistory | WorkbookRecoverHistoryPermission | Peut restaurer l’historique | | univerAPI.Enum.WorkbookPermissionPoint.CreateProtection | WorkbookCreateProtectPermission | Peut créer une protection | | univerAPI.Enum.WorkbookPermissionPoint.InsertRow | WorkbookInsertRowPermission | Peut insérer des lignes | | univerAPI.Enum.WorkbookPermissionPoint.InsertColumn | WorkbookInsertColumnPermission | Peut insérer des colonnes | | univerAPI.Enum.WorkbookPermissionPoint.DeleteRow | WorkbookDeleteRowPermission | Peut supprimer des lignes | | univerAPI.Enum.WorkbookPermissionPoint.DeleteColumn | WorkbookDeleteColumnPermission | Peut supprimer des colonnes | ### Autorisations de la feuille de calcul | Énumération de l’API | Classe de point d’autorisation correspondante | Description | | -------------------------------------------------------------- | --------------------------------------------- | --------------------------------------------- | | univerAPI.Enum.WorksheetPermissionPoint.Edit | WorksheetEditPermission | Peut modifier | | univerAPI.Enum.WorksheetPermissionPoint.View | WorksheetViewPermission | Peut afficher | | univerAPI.Enum.WorksheetPermissionPoint.Copy | WorksheetCopyPermission | Peut copier | | univerAPI.Enum.WorksheetPermissionPoint.SetCellValue | WorksheetSetCellValuePermission | Peut modifier les valeurs des cellules | | univerAPI.Enum.WorksheetPermissionPoint.SetCellStyle | WorksheetSetCellStylePermission | Peut modifier le style des cellules | | univerAPI.Enum.WorksheetPermissionPoint.SetRowStyle | WorksheetSetRowStylePermission | Peut définir le style des lignes | | univerAPI.Enum.WorksheetPermissionPoint.SetColumnStyle | WorksheetSetColumnStylePermission | Peut définir le style des colonnes | | univerAPI.Enum.WorksheetPermissionPoint.InsertRow | WorksheetInsertRowPermission | Peut insérer des lignes | | univerAPI.Enum.WorksheetPermissionPoint.InsertColumn | WorksheetInsertColumnPermission | Peut insérer des colonnes | | univerAPI.Enum.WorksheetPermissionPoint.DeleteRow | WorksheetDeleteRowPermission | Peut supprimer des lignes | | univerAPI.Enum.WorksheetPermissionPoint.DeleteColumn | WorksheetDeleteColumnPermission | Peut supprimer des colonnes | | univerAPI.Enum.WorksheetPermissionPoint.Sort | WorksheetSortPermission | Peut trier | | univerAPI.Enum.WorksheetPermissionPoint.Filter | WorksheetFilterPermission | Peut filtrer | | univerAPI.Enum.WorksheetPermissionPoint.PivotTable | WorksheetPivotTablePermission | Peut utiliser les tableaux croisés dynamiques | | univerAPI.Enum.WorksheetPermissionPoint.InsertHyperlink | WorksheetInsertHyperlinkPermission | Peut utiliser les liens hypertextes | | univerAPI.Enum.WorksheetPermissionPoint.ManageCollaborator | WorksheetManageCollaboratorPermission | Peut gérer les collaborateurs | | univerAPI.Enum.WorksheetPermissionPoint.DeleteProtection | WorksheetDeleteProtectionPermission | Peut supprimer la protection | | univerAPI.Enum.WorksheetPermissionPoint.EditExtraObject | WorksheetEditExtraObjectPermission | Peut modifier les objets supplémentaires | | univerAPI.Enum.WorksheetPermissionPoint.SelectProtectedCells | WorksheetSelectProtectedCellsPermission | Peut sélectionner les cellules protégées | | univerAPI.Enum.WorksheetPermissionPoint.SelectUnProtectedCells | WorksheetSelectUnProtectedCellsPermission | Peut sélectionner les cellules non protégées | ### Protection des plages | Énumération de l’API | Classe de point d’autorisation correspondante | Description | | ------------------------------------------------------ | ---------------------------------------------- | -------------------------------------------------- | | univerAPI.Enum.RangePermissionPoint.Edit | RangeProtectionPermissionEditPoint | Peut modifier les plages protégées | | univerAPI.Enum.RangePermissionPoint.View | RangeProtectionPermissionViewPoint | Peut afficher le contenu des plages protégées | | univerAPI.Enum.RangePermissionPoint.Delete | RangeProtectionPermissionDeleteProtectionPoint | Peut supprimer les plages protégées | | univerAPI.Enum.RangePermissionPoint.ManageCollaborator | RangeProtectionPermissionManageCollaPoint | Peut gérer les collaborateurs des plages protégées | ## Configuration de l’interface des permissions ### Stratégie d’ombrage des plages protégées Pour distinguer les zones protégées que l’utilisateur actuel peut modifier de celles qu’il ne peut pas modifier, utilisez `non-editable`. L’ombrage disparaît des zones protégées modifiables et reste visible lorsque le droit de modification est désactivé. Les plages protégées non consultables restent masquées. Ce réglage contrôle l’affichage de la protection des plages et des feuilles. Il ne crée pas de règles de protection, ne modifie pas les droits de modification ou de consultation et n’ajoute pas d’ombrage aux zones non protégées. Configurez d’abord les règles et les droits de l’utilisateur actuel comme indiqué ci-dessus. | Stratégie | Affichage | | ------------------- | ------------------------------------------------------------------------------------------------ | | `true` / `'always'` | Afficher l’ombrage de toutes les zones protégées (par défaut). | | `'non-editable'` | Masquer l’ombrage des zones protégées modifiables et le conserver sur les zones non modifiables. | | `'non-viewable'` | Afficher l’ombrage uniquement sur les zones protégées non consultables. | | `false` / `'none'` | Masquer tous les ombrages de protection ; les contrôles des droits restent actifs. | Définissez la stratégie à l’initialisation : #### Mode plugin ```typescript univer.registerPlugin(UniverSheetsUIPlugin, { protectedRangeShadow: 'non-editable', }) ``` #### Mode prédéfini ```typescript createUniver({ presets: [ UniverSheetsCorePreset({ sheets: { protectedRangeShadow: 'non-editable', }, }), ], }) ``` Vous pouvez également le modifier dynamiquement avec l’API : L’API Facade ci-dessous met à jour les classeurs existants dans l’instance Univer actuelle. En mode plugin, importez d’abord `@univerjs/sheets-ui/facade` ; le preset Sheets Core inclut déjà cet import. ```typescript // Set to only show shadows for non-editable ranges univerAPI.setProtectedRangeShadowStrategy('non-editable') // Get the current protected range shadow display strategy console.log(univerAPI.getProtectedRangeShadowStrategy()) // Subscribe to changes in the protected range shadow strategy const subscription = univerAPI.getProtectedRangeShadowStrategy$().subscribe((strategy) => { console.log('Global strategy changed to:', strategy) // Update UI or perform other actions }) // Later, unsubscribe to clean up subscription.unsubscribe() ``` ### Composant utilisateur personnalisé Le sélecteur d’utilisateurs intégré à Univer offre une souplesse limitée. Pour les cas plus complexes, vous pouvez fournir un composant personnalisé comme ci-dessous. > [!NOTE] > Pour savoir comment créer des composants personnalisés, consultez la page [Composants personnalisés](https://docs.univer.ai/fr-FR/guides/sheets/ui/components.md). #### Mode plugin ```typescript univer.registerPlugin(UniverSheetsUIPlugin, { protectedRangeUserSelector: { /** * Custom component; must implement the `IPermissionDetailUserPartProps` interface. */ component: CustomPermissionDetailUserPart, /** * The framework of the component. Must be passed correctly. */ framework: 'react', }, }) ``` #### Mode prédéfini ```typescript const { univer } = createUniver({ presets: [ UniverSheetsCorePreset({ sheets: { protectedRangeUserSelector: { /** * Custom component; must implement the `IPermissionDetailUserPartProps` interface. */ component: CustomPermissionDetailUserPart, /** * The framework of the component. Must be passed correctly. */ framework: 'react', }, }, }), ], }) ``` Appelez `setSelectUserList()` dans le gestionnaire de changement du sélecteur. Cet exemple React minimal efface la sélection : `useDependency` s’exécute dans le composant et le service ne change qu’au clic. Complétez le sélecteur selon `IPermissionDetailUserPartProps`. #### Mode plugin ```tsx import type { IPermissionDetailUserPartProps } from '@univerjs/sheets-ui' import type { FC } from 'react' import { SheetPermissionUserManagerService } from '@univerjs/sheets-ui' import { useDependency } from '@univerjs/ui' export const CustomPermissionDetailUserPart: FC = () => { const service = useDependency(SheetPermissionUserManagerService) const clearSelection = () => service.setSelectUserList([]) return } ``` #### Mode prédéfini ```tsx import type { IPermissionDetailUserPartProps } from '@univerjs/preset-sheets-core' import type { FC } from 'react' import { SheetPermissionUserManagerService, useDependency } from '@univerjs/preset-sheets-core' export const CustomPermissionDetailUserPart: FC = () => { const service = useDependency(SheetPermissionUserManagerService) const clearSelection = () => service.setSelectUserList([]) return } ``` ### Masquer la boîte de dialogue des autorisations ```typescript univerAPI.setPermissionDialogVisible(false) ``` ## Intégration du service d’autorisation ### Utilisation avancée Pour vérifier les autorisations dans votre propre plugin, vous pouvez manipuler directement les points d’autorisation. L’exemple suivant utilise `WorkbookEditablePermission` pour montrer comment vérifier les autorisations dans votre propre plugin. Les autres points d’autorisation fonctionnent de la même façon. ```typescript import { IPermissionService } from '@univerjs/core' import { WorkbookEditablePermission } from '@univerjs/sheets' class YourService { constructor(@IPermissionService private _permissionService: IPermissionService) { } setWorkbookNotEditable() { this._permissionService.updatePermissionPoint(new WorkbookEditablePermission('unitId').id, false) } setWorkbookEditable() { this._permissionService.updatePermissionPoint(new WorkbookEditablePermission('unitId').id, true) } } ``` [Liste des points d’autorisation](#point-list) ### Étendre les points d’autorisation Pour personnaliser les points d’autorisation, implémentez `IPermissionPoint`, puis enregistrez-le auprès du service d’autorisation : ```typescript import type { IPermissionPoint } from '@univerjs/core' import { IPermissionService, PermissionStatus } from '@univerjs/core' import { UnitAction, UnitObject } from '@univerjs/protocol' export class CustomPermissionPoint implements IPermissionPoint { type = UnitObject.Unkonwn // your type subType = UnitAction.View // your subType status = PermissionStatus.INIT value = true // Default value id: string constructor(unitId: string, subUnitId: string, customId: string) { // The id must be unique within `IPermissionService`. this.id = `${unitId}.${subUnitId}.${customId}` } } class YourService { constructor(@IPermissionService private _permissionService: IPermissionService) { this._init() } _init() { this._permissionService.addPermissionPoint(new CustomPermissionPoint('unitId', 'subUnitId', 'my-id')) } } // How to use it elsewhere class ConsumeService { constructor(@IPermissionService private _permissionService: IPermissionService) { } doSomething() { const point = this._permissionService.getPermissionPoint(new CustomPermissionPoint('unitId', 'subUnitId', 'my-id').id) console.log(point?.value) } bindEvent() { // This returns an RxJS observable that lets you listen for permission changes const point$ = this._permissionService.getPermissionPoint$(new CustomPermissionPoint('unitId', 'subUnitId', 'my-id').id) console.log(point$) } } ``` ### Intégrer un service d’autorisation tiers (avancé) Implémentez [IAuthzIoService](https://github.com/dream-num/univer/blob/dev/packages/core/src/services/authz-io/type.ts) dans votre application et reliez ses méthodes de permissions, rôles et collaborateurs au backend. Cet exemple suppose que `./authorization-service` exporte cette implémentation sous le nom `YourAuthzService`. Enregistrez-la avant de créer les classeurs, en conservant les autres options et plugins. ```typescript import { IAuthzIoService, Univer } from '@univerjs/core' import { YourAuthzService } from './authorization-service' const univer = new Univer({ override: [[IAuthzIoService, { useClass: YourAuthzService }]], }) ``` Le service doit persister les règles et les changements de collaborateurs, retourner les droits de l’utilisateur actuel et propager les échecs de requête. Des listes vides simulées ne constituent pas une persistance. En collaboration, le backend doit vérifier séparément les droits de lecture, JOIN et modification ; voir [Identité et autorisation](https://docs.univer.ai/fr-FR/server/collaboration/identity-and-authorization.md). La protection de l’interface et le masquage des ombres ne remplacent pas l’autorisation serveur. ![Autorisation](https://raw.githubusercontent.com/dream-num/documentation/dev/content/guides/sheets/features/core/permission/permission-en.png) ### Gestion des collaborateurs > [!NOTE] > La gestion des collaborateurs appartient au modèle utilisateurs/ACL et au service de permissions de votre application. Protégez lecture, JOIN et modification selon [Identity and authorization](https://docs.univer.ai/fr-FR/server/collaboration/identity-and-authorization.md). Les API frontend ci-dessous nécessitent une implémentation correspondante du service de permissions. * Obtenir la liste des collaborateurs ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const workbookPermission = fWorkbook.getWorkbookPermission() const collaborators = await workbookPermission.listCollaborators() console.log(collaborators) ``` * Ajouter des collaborateurs ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const workbookPermission = fWorkbook.getWorkbookPermission() // Add multiple collaborators at once await workbookPermission.setCollaborators([ { user: { userID: 'user1', name: 'John Doe', avatar: 'https://...' }, role: univerAPI.Enum.UnitRole.Editor, }, { user: { userID: 'user2', name: 'Jane Smith', avatar: '' }, role: univerAPI.Enum.UnitRole.Reader, }, ]) // Add a single collaborator await workbookPermission.addCollaborator( { userID: 'user1', name: 'John Doe', avatar: 'https://...' }, univerAPI.Enum.UnitRole.Editor, ) ``` * Modifier le rôle d’un collaborateur ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const workbookPermission = fWorkbook.getWorkbookPermission() await workbookPermission.updateCollaborator( { userID: 'user1', name: 'John Doe Updated', avatar: 'https://...' }, univerAPI.Enum.UnitRole.Reader, ) ``` * Supprimer des collaborateurs ```typescript const fWorkbook = univerAPI.getActiveWorkbook() if (!fWorkbook) throw new Error('No active workbook') const workbookPermission = fWorkbook.getWorkbookPermission() // Remove multiple collaborators await workbookPermission.removeCollaborators(['user1', 'user2']) // Remove a single collaborator await workbookPermission.removeCollaborator('user1') ``` ## Reference * [FWorkbookPermission](https://docs.univer.ai/fr-FR/reference/facade/workbook-permission.md) * [FWorksheetPermission](https://docs.univer.ai/fr-FR/reference/facade/worksheet-permission.md) * [FRangePermission](https://docs.univer.ai/fr-FR/reference/facade/range-permission.md) * [FRangeProtectionRule](https://docs.univer.ai/fr-FR/reference/facade/range-protection-rule.md)