update: add `checkPolicyProperties` function to handle policies 🪄

npm/ng-packs/packages/components/extensible/src/lib/utils/props.util.ts

@@ -22,6 +22,9 @@ import {
   PropList,
   PropsFactory,
 } from '../models/props';
+import { PolicyGroup } from '../models/internal/object-extensions';
+import { ObjectExtensions } from '../models/object-extensions';
+import { ConfigStateService, PermissionService } from '@abp/ng.core';
 
 export function createExtraPropertyValueResolver<T>(
   name: string,
@@ -47,6 +50,59 @@ export function mergeWithDefaultProps<F extends PropsFactory<any>>(
     );
   });
 }
+
+function isPolicyMet(
+  checkFunction: (item: string) => boolean,
+  requiresAll: boolean,
+  items?: string[],
+): boolean {
+  if (!items?.length) {
+    return true;
+  }
+  return requiresAll ? items.every(checkFunction) : items.some(checkFunction);
+}
+
+export function checkPolicyProperties(
+  properties: ObjectExtensions.EntityExtensionProperties,
+  configState: ConfigStateService,
+  permissionService?: PermissionService,
+) {
+  //TODO this check will be removed after configuring every contribution in the row 🪄
+  if (!permissionService) return;
+
+  const checkPolicy = (policy: PolicyGroup): boolean => {
+    const { permissions, globalFeatures, features } = policy;
+
+    const checks = [
+      {
+        items: permissions?.permissionNames,
+        requiresAll: permissions?.requiresAll,
+        check: (item: string) => permissionService.getGrantedPolicy(item),
+      },
+      {
+        items: globalFeatures?.features,
+        requiresAll: globalFeatures?.requiresAll,
+        check: (item: string) => configState.getGlobalFeatureIsEnabled(item),
+      },
+      {
+        items: features?.features,
+        requiresAll: features?.requiresAll,
+        check: (item: string) => configState.getFeatureIsEnabled(item),
+      },
+    ];
+
+    return checks.every(({ items, requiresAll, check }) =>
+      isPolicyMet(check, requiresAll ?? false, items),
+    );
+  };
+
+  Object.entries(properties).forEach(([name, property]) => {
+    if (property.policy && !checkPolicy(property.policy)) {
+      delete properties[name];
+    }
+  });
+}
+
 type InferredPropDefaults<F> =
   F extends EntityPropsFactory<infer RE>
     ? EntityPropDefaults<RE>
@@ -73,3 +129,108 @@ type InferredProps<F> =
       : F extends EditFormPropsFactory<infer REF>
         ? FormProps<REF>
         : never;
+
+// export function checkPolicyProperties(
+//   properties: ObjectExtensions.EntityExtensionProperties,
+//   configState: ConfigStateService,
+//   permissionService?: PermissionService,
+// ) {
+//   Object.keys(properties).forEach((name: string) => {
+//     const property = properties[name];
+
+//     if (!property.policy) {
+//       return;
+//     }
+
+//     let isPolicyConstraintMet = false;
+
+//     const { permissions, features, globalFeatures } = property.policy;
+
+//     if (!permissionService) {
+//       return;
+//     }
+
+//     if (!permissions.permissionNames) {
+//       return;
+//     }
+
+//     const hasPermission = (permission: string): boolean =>
+//       permissionService.getGrantedPolicy(permission);
+
+//     isPolicyConstraintMet = permissions.requiresAll
+//       ? permissions.permissionNames.every(hasPermission)
+//       : permissions.permissionNames.some(hasPermission);
+
+//     if (!isPolicyConstraintMet) {
+//       delete properties[name];
+//     }
+
+//     if (!globalFeatures.features) {
+//       return;
+//     }
+
+//     const hasGlobalFeature = (globalFeature: string): boolean =>
+//       configState.getGlobalFeatureIsEnabled(globalFeature);
+
+//     isPolicyConstraintMet = globalFeatures.requiresAll
+//       ? globalFeatures.features.every(hasGlobalFeature)
+//       : globalFeatures.features.some(hasGlobalFeature);
+
+//     if (!isPolicyConstraintMet) {
+//       delete properties[name];
+//     }
+
+//     const hasFeature = (feature: string): boolean => configState.getFeatureIsEnabled(feature);
+
+//     isPolicyConstraintMet = features.requiresAll
+//       ? features.features.every(hasFeature)
+//       : features.features.some(hasFeature);
+
+//     if (!isPolicyConstraintMet) {
+//       delete properties[name];
+//     }
+//   });
+// }
+
+// export function checkPolicyProperties(
+//   properties: ObjectExtensions.EntityExtensionProperties,
+//   configState: ConfigStateService,
+//   permissionService?: PermissionService,
+// ) {
+//   if (!permissionService) return;
+
+//   const isConstraintMet = (
+//     items: string[] | undefined,
+//     requiresAll: boolean | undefined,
+//     checkFunction: (item: string) => boolean,
+//   ): boolean =>
+//     !items ||
+//     items.length === 0 ||
+//     (requiresAll ? items.every(checkFunction) : items.some(checkFunction));
+
+//   const policyCheckers = [
+//     {
+//       getItems: (policy: any) => policy.permissions?.permissionNames,
+//       check: (permission: string) => permissionService.getGrantedPolicy(permission),
+//     },
+//     {
+//       getItems: (policy: any) => policy.globalFeatures?.features,
+//       check: (feature: string) => configState.getGlobalFeatureIsEnabled(feature),
+//     },
+//     {
+//       getItems: (policy: any) => policy.features?.features,
+//       check: (feature: string) => configState.getFeatureIsEnabled(feature),
+//     },
+//   ];
+
+//   Object.keys(properties).forEach((name: string) => {
+//     const { policy } = properties[name];
+//     if (!policy) return;
+
+//     const shouldDelete = policyCheckers.some(
+//       ({ getItems, check }) => !isConstraintMet(getItems(policy), policy.features.requiresAll, check),
+//     );
+
+//     if (shouldDelete) delete properties[name];
+//   });
+// }

npm/ng-packs/packages/components/extensible/src/lib/utils/state.util.ts

@@ -5,6 +5,7 @@ import {
   ExtensionEnumDto,
   ExtensionPropertyUiLookupDto,
   ObjectExtensionsDto,
+  PermissionService,
 } from '@abp/ng.core';
 import { Observable, pipe, zip } from 'rxjs';
 import { filter, map, switchMap, take } from 'rxjs/operators';
@@ -15,7 +16,7 @@ import { ObjectExtensions } from '../models/object-extensions';
 import { PropCallback } from '../models/props';
 import { createEnum, createEnumOptions, createEnumValueResolver } from './enum.util';
 import { createDisplayNameLocalizationPipeKeyGenerator } from './localization.util';
-import { createExtraPropertyValueResolver } from './props.util';
+import { checkPolicyProperties, createExtraPropertyValueResolver } from './props.util';
 import {
   createTypeaheadDisplayNameGenerator,
   createTypeaheadOptions,
@@ -39,15 +40,18 @@ function selectEnums(
 ): Observable<Record<string, ExtensionEnumDto>> {
   return selectObjectExtensions(configState).pipe(
     map((extensions: ObjectExtensionsDto) =>
-      Object.keys(extensions.enums).reduce((acc, key) => {
-        const { fields, localizationResource } = extensions.enums[key];
-        acc[key] = {
-          fields,
-          localizationResource,
-          transformed: createEnum(fields),
-        };
-        return acc;
-      }, {} as Record<string, ObjectExtensions.ExtensionEnumDto>),
+      Object.keys(extensions.enums).reduce(
+        (acc, key) => {
+          const { fields, localizationResource } = extensions.enums[key];
+          acc[key] = {
+            fields,
+            localizationResource,
+            transformed: createEnum(fields),
+          };
+          return acc;
+        },
+        {} as Record<string, ObjectExtensions.ExtensionEnumDto>,
+      ),
     ),
   );
 }
@@ -72,6 +76,7 @@ export function getObjectExtensionEntitiesFromStore(
 export function mapEntitiesToContributors<T = any>(
   configState: ConfigStateService,
   resource: string,
+  permissionService?: PermissionService,
 ) {
   return pipe(
     switchMap((entities: any) =>
@@ -86,10 +91,16 @@ export function mapEntitiesToContributors<T = any>(
               acc.editForm[key] = [];
 
               const entity: ObjectExtensions.EntityExtensionDto = entities[key];
-              if (!entity) return acc;
+              if (!entity) {
+                return acc;
+              }
 
               const properties = entity.properties;
-              if (!properties) return acc;
+              if (!properties) {
+                return acc;
+              }
+
+              checkPolicyProperties(properties, configState, permissionService);
 
               const mapPropertiesToContributors = createPropertiesToContributorsMapper<T>(
                 generateDisplayName,