fix(permission): keep permision point ref (#2532)

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>>();
  public permissionPointUpdate$ = this._permissionPointUpdate$.asObservable();
@@ -35,15 +35,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;
  };
@@ -104,4 +106,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);
  });
  });