@finos/legend-application-marketplace 0.1.55 → 0.1.57

package/src/stores/lakehouse/entitlements/EntitlementsDashboardState.ts

@@ -17,6 +17,7 @@
 import {
   ActionState,
   assertErrorThrown,
+  guaranteeNonNullable,
   isNonNullable,
   type GeneratorFn,
   type PlainObject,
@@ -24,34 +25,82 @@ import {
 import { deserialize } from 'serializr';
 import {
   type V1_ContractUserEventRecord,
+  type V1_DataContract,
+  type V1_EnrichedUserApprovalStatus,
   type V1_LiteDataContract,
-  type V1_LiteDataContractsResponse,
   type V1_LiteDataContractWithUserStatus,
   type V1_PendingTasksResponse,
   type V1_TaskStatus,
   type V1_TaskStatusChangeResponse,
-  type V1_UserPendingContractsRecord,
-  type V1_UserPendingContractsResponse,
-  V1_liteDataContractsResponseModelSchemaToContracts,
+  V1_dataContractsResponseModelSchema,
   V1_liteDataContractWithUserStatusModelSchema,
   V1_pendingTasksResponseModelSchema,
   V1_TaskStatusChangeResponseModelSchema,
+  V1_transformDataContractToLiteDatacontract,
 } from '@finos/legend-graph';
-import { makeObservable, flow, observable, action, flowResult } from 'mobx';
+import {
+  makeObservable,
+  flow,
+  observable,
+  flowResult,
+  action,
+  computed,
+} from 'mobx';
 import {
   TEST_USER,
-  TEST_USER2,
   type LakehouseEntitlementsStore,
 } from './LakehouseEntitlementsStore.js';
 
+export class ContractCreatedByUserDetails {
+  readonly contractResultLite: V1_LiteDataContract;
+  assignees: Set<string> = new Set();
+  members: Map<string, V1_EnrichedUserApprovalStatus> = new Map();
+
+  constructor(contract: V1_LiteDataContract) {
+    this.contractResultLite = contract;
+
+    makeObservable(this, {
+      assignees: observable,
+      members: observable,
+      sortedAssigneeIds: computed,
+      sortedMemberIds: computed,
+      addAssignees: action,
+      addMember: action,
+    });
+  }
+
+  get sortedAssigneeIds(): string[] {
+    return Array.from(this.assignees).toSorted();
+  }
+
+  get sortedMemberIds(): string[] {
+    return Array.from(this.members.keys()).toSorted();
+  }
+
+  addAssignees(assignees: string[]): void {
+    assignees.forEach((assignee) => this.assignees.add(assignee));
+  }
+
+  addMember(id: string, status: V1_EnrichedUserApprovalStatus): void {
+    this.members.set(id, status);
+  }
+}
+
 export class EntitlementsDashboardState {
   readonly lakehouseEntitlementsStore: LakehouseEntitlementsStore;
   pendingTasks: V1_ContractUserEventRecord[] | undefined;
-  pendingContracts: V1_UserPendingContractsRecord[] | undefined;
-  allContracts: V1_LiteDataContract[] | undefined;
-  myContracts: V1_LiteDataContractWithUserStatus[] | undefined;
+  pendingTaskContractMap: Map<string, V1_LiteDataContract> = new Map();
+  allContractsForUser: V1_LiteDataContractWithUserStatus[] | undefined;
+  // The contracts createdBy user API returns an entry for each task, not just for each contract.
+  // To consolidate this information, we store a map of contract ID to the contract details + the
+  // consolidated user information from the tasks.
+  allContractsCreatedByUserMap: Map<string, ContractCreatedByUserDetails> =
+    new Map();
 
   readonly initializationState = ActionState.create();
+  readonly fetchingPendingTasksState = ActionState.create();
+  readonly fetchingContractsForUserState = ActionState.create();
+  readonly fetchingContractsByUserState = ActionState.create();
   readonly changingState = ActionState.create();
 
   constructor(state: LakehouseEntitlementsStore) {
@@ -59,38 +108,52 @@ export class EntitlementsDashboardState {
 
     makeObservable(this, {
       pendingTasks: observable,
-      pendingContracts: observable,
-      allContracts: observable,
-      myContracts: observable,
-      setPendingTasks: action,
-      setPendingContracts: action,
-      setAllContracts: action,
-      setMyContracts: action,
+      allContractsForUser: observable,
+      allContractsCreatedByUserMap: observable,
+      pendingTaskContractMap: observable,
+      pendingTaskContracts: computed,
+      allContractsCreatedByUser: computed,
+      init: flow,
       approve: flow,
-      fetchPendingContracts: flow,
+      deny: flow,
       fetchPendingTasks: flow,
-      fetchAllContracts: flow,
-      fetchMyContracts: flow,
+      fetchPendingTaskContracts: flow,
+      fetchContractsForUser: flow,
+      fetchContractsCreatedByUser: flow,
       updateContract: flow,
-      init: flow,
-      deny: flow,
     });
   }
 
+  get pendingTaskContracts(): V1_LiteDataContract[] {
+    return Array.from(this.pendingTaskContractMap.values());
+  }
+
+  get allContractsCreatedByUser(): ContractCreatedByUserDetails[] {
+    return Array.from(this.allContractsCreatedByUserMap.values());
+  }
+
   *init(token: string | undefined): GeneratorFn<void> {
     this.initializationState.inProgress();
     try {
       yield Promise.all([
-        flowResult(this.fetchPendingTasks(token)).catch(
+        (async () => {
+          this.fetchingPendingTasksState.inProgress();
+          try {
+            await flowResult(this.fetchPendingTasks(token));
+            await flowResult(this.fetchPendingTaskContracts(token));
+          } catch (error) {
+            assertErrorThrown(error);
+            this.lakehouseEntitlementsStore.applicationStore.alertUnhandledError(
+              error,
+            );
+          } finally {
+            this.fetchingPendingTasksState.complete();
+          }
+        })(),
+        flowResult(this.fetchContractsForUser(token)).catch(
           this.lakehouseEntitlementsStore.applicationStore.alertUnhandledError,
         ),
-        flowResult(this.fetchPendingContracts(token)).catch(
-          this.lakehouseEntitlementsStore.applicationStore.alertUnhandledError,
-        ),
-        flowResult(this.fetchAllContracts(token)).catch(
-          this.lakehouseEntitlementsStore.applicationStore.alertUnhandledError,
-        ),
-        flowResult(this.fetchMyContracts(token)).catch(
+        flowResult(this.fetchContractsCreatedByUser(token)).catch(
           this.lakehouseEntitlementsStore.applicationStore.alertUnhandledError,
         ),
       ]);
@@ -104,33 +167,16 @@ export class EntitlementsDashboardState {
     }
   }
 
-  *fetchPendingContracts(token: string | undefined): GeneratorFn<void> {
-    try {
-      this.setPendingContracts(undefined);
-      const pendingContracts =
-        (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getPendingContracts(
-          TEST_USER2,
-          token,
-        )) as V1_UserPendingContractsResponse;
-      this.setPendingContracts(pendingContracts.records ?? []);
-    } catch (error) {
-      assertErrorThrown(error);
-      this.lakehouseEntitlementsStore.applicationStore.notificationService.notifyError(
-        `Error fetching pending contracts: ${error.message}`,
-      );
-    }
-  }
-
   *fetchPendingTasks(token: string | undefined): GeneratorFn<void> {
     try {
-      this.setPendingTasks(undefined);
+      this.pendingTasks = undefined;
       const rawTasks =
         (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getPendingTasks(
           TEST_USER,
           token,
         )) as PlainObject<V1_PendingTasksResponse>;
       const tasks = deserialize(V1_pendingTasksResponseModelSchema, rawTasks);
-      this.setPendingTasks([...tasks.dataOwner, ...tasks.privilegeManager]);
+      this.pendingTasks = [...tasks.dataOwner, ...tasks.privilegeManager];
     } catch (error) {
       assertErrorThrown(error);
       this.lakehouseEntitlementsStore.applicationStore.notificationService.notifyError(
@@ -139,31 +185,74 @@ export class EntitlementsDashboardState {
     }
   }
 
-  *fetchAllContracts(token: string | undefined): GeneratorFn<void> {
+  *fetchPendingTaskContracts(token: string | undefined): GeneratorFn<void> {
+    const pendingTaskContractIds = Array.from(
+      new Set(this.pendingTasks?.map((t) => t.dataContractId) ?? []),
+    );
+    const pendingTaskContracts = (
+      (yield Promise.all(
+        pendingTaskContractIds.map(async (contractId) => {
+          const rawContractResponse =
+            await this.lakehouseEntitlementsStore.lakehouseContractServerClient.getDataContract(
+              contractId,
+              false,
+              token,
+            );
+          const contractResponse = deserialize(
+            V1_dataContractsResponseModelSchema(
+              this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+            ),
+            rawContractResponse,
+          );
+          return contractResponse.dataContracts?.[0]?.dataContract;
+        }),
+      )) as (V1_DataContract | undefined)[]
+    )
+      .filter(isNonNullable)
+      .map(V1_transformDataContractToLiteDatacontract);
+    pendingTaskContractIds.forEach((contractId) => {
+      const contract = pendingTaskContracts.find((c) => c.guid === contractId);
+      if (contract) {
+        this.pendingTaskContractMap.set(contractId, contract);
+      }
+    });
+  }
+
+  *fetchContractsForUser(token: string | undefined): GeneratorFn<void> {
+    this.fetchingContractsForUserState.inProgress();
     try {
-      this.setAllContracts(undefined);
+      this.allContractsForUser = undefined;
       const rawContracts =
-        (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getLiteDataContracts(
+        (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getContractsForUser(
+          this.lakehouseEntitlementsStore.applicationStore.identityService
+            .currentUser,
           token,
-        )) as PlainObject<V1_LiteDataContractsResponse>;
-      const contracts = V1_liteDataContractsResponseModelSchemaToContracts(
-        rawContracts,
-        this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+        )) as PlainObject<V1_LiteDataContractWithUserStatus>[];
+      const contracts = rawContracts.map((rawContract) =>
+        deserialize(
+          V1_liteDataContractWithUserStatusModelSchema(
+            this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+          ),
+          rawContract,
+        ),
       );
-      this.setAllContracts([...contracts]);
+      this.allContractsForUser = [...contracts];
     } catch (error) {
       assertErrorThrown(error);
       this.lakehouseEntitlementsStore.applicationStore.notificationService.notifyError(
-        `Error fetching all data contracts: ${error.message}`,
+        `Error fetching data contracts for user: ${error.message}`,
       );
+    } finally {
+      this.fetchingContractsForUserState.complete();
     }
   }
 
-  *fetchMyContracts(token: string | undefined): GeneratorFn<void> {
+  *fetchContractsCreatedByUser(token: string | undefined): GeneratorFn<void> {
+    this.fetchingContractsByUserState.inProgress();
     try {
-      this.setMyContracts(undefined);
+      this.allContractsCreatedByUserMap = new Map();
       const rawContracts =
-        (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getContractsForUser(
+        (yield this.lakehouseEntitlementsStore.lakehouseContractServerClient.getContractsCreatedByUser(
           this.lakehouseEntitlementsStore.applicationStore.identityService
             .currentUser,
           token,
@@ -176,73 +265,109 @@ export class EntitlementsDashboardState {
           rawContract,
         ),
       );
-      this.setMyContracts([...contracts]);
+      contracts.forEach((contract) => {
+        if (
+          !this.allContractsCreatedByUserMap.has(
+            contract.contractResultLite.guid,
+          )
+        ) {
+          this.allContractsCreatedByUserMap.set(
+            contract.contractResultLite.guid,
+            new ContractCreatedByUserDetails(contract.contractResultLite),
+          );
+        }
+        const entry = guaranteeNonNullable(
+          this.allContractsCreatedByUserMap.get(
+            contract.contractResultLite.guid,
+          ),
+        );
+        entry.addAssignees(contract.pendingTaskWithAssignees?.assignees ?? []);
+        entry.addMember(contract.user, contract.status);
+      });
     } catch (error) {
       assertErrorThrown(error);
       this.lakehouseEntitlementsStore.applicationStore.notificationService.notifyError(
-        `Error fetching all data contracts: ${error.message}`,
+        `Error fetching data contracts created by user: ${error.message}`,
       );
+    } finally {
+      this.fetchingContractsByUserState.complete();
     }
   }
 
-  setPendingTasks(val: V1_ContractUserEventRecord[] | undefined): void {
-    this.pendingTasks = val;
-  }
-
-  setPendingContracts(val: V1_UserPendingContractsRecord[] | undefined): void {
-    this.pendingContracts = val;
-  }
-
-  setAllContracts(val: V1_LiteDataContract[] | undefined): void {
-    this.allContracts = val;
-  }
-
-  setMyContracts(val: V1_LiteDataContractWithUserStatus[] | undefined): void {
-    this.myContracts = val;
-  }
-
   *updateContract(
     contractId: string,
     token: string | undefined,
   ): GeneratorFn<void> {
-    const [newPendingContracts, newAllContracts] = (yield Promise.all([
-      (async () =>
-        (
-          await this.lakehouseEntitlementsStore.lakehouseContractServerClient.getPendingContracts(
-            TEST_USER2,
+    const [newUserContracts, newCreatedByUserContracts] = (yield Promise.all([
+      (async () => {
+        const rawContracts =
+          await this.lakehouseEntitlementsStore.lakehouseContractServerClient.getContractsForUser(
+            this.lakehouseEntitlementsStore.applicationStore.identityService
+              .currentUser,
             token,
-          )
-        ).records ?? [])(),
+          );
+        return rawContracts.map((rawContract) =>
+          deserialize(
+            V1_liteDataContractWithUserStatusModelSchema(
+              this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+            ),
+            rawContract,
+          ),
+        );
+      })(),
       (async () => {
         const rawContracts =
-          await this.lakehouseEntitlementsStore.lakehouseContractServerClient.getLiteDataContracts(
+          await this.lakehouseEntitlementsStore.lakehouseContractServerClient.getContractsCreatedByUser(
+            this.lakehouseEntitlementsStore.applicationStore.identityService
+              .currentUser,
             token,
           );
-        return V1_liteDataContractsResponseModelSchemaToContracts(
-          rawContracts,
-          this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+        return rawContracts.map((rawContract) =>
+          deserialize(
+            V1_liteDataContractWithUserStatusModelSchema(
+              this.lakehouseEntitlementsStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+            ),
+            rawContract,
+          ),
         );
       })(),
-    ])) as [V1_UserPendingContractsRecord[], V1_LiteDataContract[]];
+    ])) as [
+      V1_LiteDataContractWithUserStatus[],
+      V1_LiteDataContractWithUserStatus[],
+    ];
 
-    this.setPendingContracts(
-      this.pendingContracts
-        ?.map((contract) =>
-          contract.contractId === contractId
-            ? newPendingContracts.find((c) => c.contractId === contractId)
-            : contract,
-        )
-        .filter(isNonNullable),
-    );
-    this.setAllContracts(
-      this.allContracts
-        ?.map((contract) =>
-          contract.guid === contractId
-            ? newAllContracts.find((c) => c.guid === contractId)
-            : contract,
-        )
-        .filter(isNonNullable),
+    // Update the contract for the user
+    this.allContractsForUser = this.allContractsForUser
+      ?.map((contract) =>
+        contract.contractResultLite.guid === contractId
+          ? newUserContracts.find(
+              (c) => c.contractResultLite.guid === contractId,
+            )
+          : contract,
+      )
+      .filter(isNonNullable);
+
+    // Update the contract + all related data for contract created by the user
+    this.allContractsCreatedByUserMap.delete(contractId);
+    const updatedCreatedByUserContracts = newCreatedByUserContracts.filter(
+      (c) => c.contractResultLite.guid === contractId,
     );
+
+    updatedCreatedByUserContracts.forEach((contract) => {
+      if (
+        !this.allContractsCreatedByUserMap.has(contract.contractResultLite.guid)
+      ) {
+        this.allContractsCreatedByUserMap.set(
+          contract.contractResultLite.guid,
+          new ContractCreatedByUserDetails(contract.contractResultLite),
+        );
+      }
+      const entry = guaranteeNonNullable(
+        this.allContractsCreatedByUserMap.get(contract.contractResultLite.guid),
+      );
+      entry.addAssignees(contract.pendingTaskWithAssignees?.assignees ?? []);
+      entry.addMember(contract.user, contract.status);
+    });
   }
 
   *approve(
@@ -267,7 +392,7 @@ export class EntitlementsDashboardState {
         );
       }
       task.status = change.status;
-      this.setPendingTasks([...(this.pendingTasks ?? [])]);
+      this.pendingTasks = [...(this.pendingTasks ?? [])];
       this.lakehouseEntitlementsStore.applicationStore.notificationService.notifySuccess(
         `Task has been Approved`,
       );
@@ -305,7 +430,7 @@ export class EntitlementsDashboardState {
         );
       }
       task.status = change.status;
-      this.setPendingTasks([...(this.pendingTasks ?? [])]);
+      this.pendingTasks = [...(this.pendingTasks ?? [])];
       this.lakehouseEntitlementsStore.applicationStore.notificationService.notifySuccess(
         `Task has been denied`,
       );

package/src/stores/orders/OrderHelpers.ts

@@ -146,13 +146,14 @@ export const isStageRejected = (
   return false;
 };
 
-export const formatOrderDate = (dateString: string): string => {
-  const date = new Date(dateString);
-  return date.toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-  });
+export const formatOrderDate = (dateString?: string): string | undefined => {
+  return dateString
+    ? new Date(dateString).toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+      })
+    : undefined;
 };
 
 export const formatTimestamp = (timestamp: string): string => {