fix(permission): keep permision point ref

packages/core/src/services/permission/permission.service.ts

@@ -22,7 +22,7 @@ import type { IPermissionPoint, IPermissionService } from './type';
 import { PermissionStatus } from './type';
 
 export class PermissionService extends Disposable implements IPermissionService {
-    private _permissionPointMap: Map<string, BehaviorSubject<IPermissionPoint<unknown>>> = new Map();
+    private _permissionPointMap: Map<string, BehaviorSubject<IPermissionPoint<any>>> = new Map();
 
     private _permissionPointUpdate$ = new Subject<IPermissionPoint<unknown>>();
 
@@ -36,15 +36,17 @@ export class PermissionService extends Disposable implements IPermissionService
         }
     };
 
-    addPermissionPoint<T = boolean>(item: IPermissionPoint<T>) {
+    addPermissionPoint<T = boolean>(_item: IPermissionPoint<T> | BehaviorSubject<IPermissionPoint<T>>) {
+        const isSubject = _item instanceof BehaviorSubject;
+        const item = isSubject ? _item.getValue() : _item;
         if (!item.id) {
             return false;
         }
         const permissionPoint = this._permissionPointMap.get(item.id);
         if (permissionPoint) {
-            throw new Error('PermissionPoint already exists');
+            throw new Error(`${item.id} PermissionPoint already exists`);
         }
-        this._permissionPointMap.set(item.id, new BehaviorSubject<IPermissionPoint<unknown>>(item));
+        this._permissionPointMap.set(item.id, isSubject ? _item : new BehaviorSubject<IPermissionPoint<unknown>>(item));
         this._permissionPointUpdate$.next(item);
         return true;
     };
@@ -105,4 +107,12 @@ export class PermissionService extends Disposable implements IPermissionService
 
         return valueList;
     }
+
+    getAllPermissionPoint() {
+        const cacheMap = new Map<string, BehaviorSubject<IPermissionPoint<unknown>>>();
+        this._permissionPointMap.forEach((v, key) => {
+            cacheMap.set(key, v);
+        });
+        return cacheMap;
+    }
 }

packages/core/src/services/permission/type.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { Observable } from 'rxjs';
+import type { BehaviorSubject, Observable } from 'rxjs';
 import { createIdentifier } from '@wendellhu/redi';
 import type { UnitAction, UnitObject } from '@univerjs/protocol';
 import type { Nullable } from '../../common/type-utils';
@@ -54,14 +54,15 @@ export interface IPermissionParam {
 export interface IPermissionService {
     permissionPointUpdate$: Observable<IPermissionPoint<unknown>>;
     deletePermissionPoint(permissionId: string): void;
-    addPermissionPoint<T = boolean>(permissionPoint: IPermissionPoint<T>): boolean;
+    addPermissionPoint<T = boolean>(permissionPoint: IPermissionPoint<T> | BehaviorSubject<IPermissionPoint<T>>): boolean;
     updatePermissionPoint<T = boolean>(permissionId: string, value: T): void;
     getPermissionPoint<T = boolean>(permissionId: string): Nullable<IPermissionPoint<T>>;
     getPermissionPoint$<T = boolean>(permissionId: string): Nullable<Observable<IPermissionPoint<T>>>;
     clearPermissionMap(): void;
 
     composePermission$(permissionId: string[]): Observable<IPermissionPoint<unknown>[]>;
     composePermission(permissionId: string[]): IPermissionPoint<unknown>[];
+    getAllPermissionPoint(): Map<string, Observable<IPermissionPoint<unknown>>>;
 }
 
 export const IPermissionService = createIdentifier<IPermissionService>('univer.permission-service');

packages/sheets-ui/src/controllers/permission/sheet-permission-init.controller.ts

@@ -270,28 +270,42 @@ export class SheetPermissionInitController extends Disposable {
     private _initUserChange() {
         this.disposeWithMe(
             this._userManagerService.currentUser$.subscribe(() => {
+                // This is to minimize the need for access providers to update the reference to permission points when the current user changes, reducing the integration steps required.
+                // If not handled this way, the access providers would have to handle the changes in user and the resulting changes in permission point references.
+                const _map = this._permissionService.getAllPermissionPoint();
+
                 this._permissionService.clearPermissionMap();
+
                 this._worksheetProtectionRuleModel.changeRuleInitState(false);
 
                 const workbook = this._univerInstanceService.getCurrentUnitForType<Workbook>(UniverInstanceType.UNIVER_SHEET)!;
                 const unitId = workbook.getUnitId();
 
                 getAllWorkbookPermissionPoint().forEach((F) => {
-                    const instance = new F(unitId);
+                    let instance = new F(unitId);
+                    if (_map.has(instance.id)) {
+                        instance = _map.get(instance.id) as any;
+                    }
                     this._permissionService.addPermissionPoint(instance);
                 });
 
                 workbook.getSheets().forEach((sheet) => {
                     const subUnitId = sheet.getSheetId();
                     [...getAllWorksheetPermissionPoint(), ...getAllWorksheetPermissionPointByPointPanel()].forEach((F) => {
-                        const instance = new F(unitId, subUnitId);
+                        let instance = new F(unitId, subUnitId);
+                        if (_map.has(instance.id)) {
+                            instance = _map.get(instance.id) as any;
+                        }
                         this._permissionService.addPermissionPoint(instance);
                     });
 
                     const ruleList = this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId);
                     ruleList.forEach((rule) => {
                         getAllRangePermissionPoint().forEach((F) => {
-                            const instance = new F(unitId, subUnitId, rule.permissionId);
+                            let instance = new F(unitId, subUnitId, rule.permissionId);
+                            if (_map.has(instance.id)) {
+                                instance = _map.get(instance.id) as any;
+                            }
                             this._permissionService.addPermissionPoint(instance);
                         });
                     });