@finos/legend-application-marketplace 0.0.20 → 0.0.21

package/src/stores/lakehouse/LakehouseUtils.ts

@@ -18,11 +18,27 @@ import {
   type V1_AccessPointGroup,
   V1_AccessPointGroupReference,
   V1_AdhocTeam,
+  V1_AppDirOrganizationalScope,
   V1_ContractState,
+  type V1_ContractUserEventRecord,
   type V1_DataContract,
   type V1_DataProduct,
+  V1_UserApprovalStatus,
 } from '@finos/legend-graph';
+import { prettyCONSTName } from '@finos/legend-shared';
 
+export enum GridTiemStatus {
+  SUCCESS = 'success',
+  ERROR = 'error',
+  INFO = 'info',
+}
+
+export type GridItemDetail = {
+  name: string;
+  value: string | number;
+  onClick?: (() => void) | undefined;
+  status?: GridTiemStatus | undefined;
+};
 const inValidContractState = [
   V1_ContractState.DRAFT,
   V1_ContractState.REJECTED,
@@ -34,6 +50,23 @@ const inProgressContractState = [
   V1_ContractState.OPEN_FOR_PRIVILEGE_MANAGER_APPROVAL,
 ];
 
+const idxLabel = (idx: number): string => {
+  return ` (${idx + 1})`;
+};
+
+export const convertMutilGridItemDetail = (
+  details: GridItemDetail[][],
+): GridItemDetail[] => {
+  if (details.length > 1) {
+    details.forEach((gridItems, idx) => {
+      gridItems.forEach((item) => {
+        item.name = `${item.name}${idxLabel(idx)}`;
+      });
+    });
+  }
+  return details.flat();
+};
+
 export const dataContractContainsDataProduct = (
   dataProduct: V1_DataProduct,
   dataProdcutDeploymentID: string | undefined,
@@ -91,3 +124,222 @@ export const isContractCompleted = (contract: V1_DataContract): boolean => {
 export const isContractPending = (contract: V1_DataContract): boolean => {
   return inProgressContractState.includes(contract.state);
 };
+
+type ContractDetailOptions = {
+  openApplicationIdHandler?: ((user: string) => void) | undefined;
+  openDirectoryHandler?: ((id: string) => void) | undefined;
+  externalReference?:
+    | {
+        openContractHandler: ((id: string) => void) | undefined;
+      }
+    | undefined;
+};
+
+const CONTRACT_GRID_NAME = Object.freeze({
+  CONTRACT_ID: 'Contract ID',
+  CONTRACT_DESCRIPTION: 'Contract Description',
+  CONTRACT_VERSION: 'Contract Version',
+  CONTRACT_STATE: 'Contract State',
+  CONTRACT_DATA_PRODUCT_ID: 'Contract Data Product ID',
+  CONTRACT_DATA_PRODUCT: 'Contract Data Product',
+  CONTRACT_DATA_PRODUCT_DID: 'Contract Data Product DID',
+  CONTRACT_ACCESS_GROUP: 'Contract Access Group',
+  CONTRACT_ACCESS_POINTS: 'Contract Access Points',
+  CONTRACT_CONSUMER_NAME: 'Contract Consumer Name',
+  CONTRACT_CONSUMER_LEVEL: 'Contract Consumer Level',
+  CONTRACT_MEMBER_ID: 'Contract Member ID',
+  CONTRACT_MEMBER_TYPE: 'Contract Member Type',
+  CONTRACT_MEMBER_STATUS: 'Contract Member Status',
+  CONTRACT_MEMBER_NAME: 'Contract Member Name',
+  CONTRACT_APP_DID: 'Contract App DID',
+  CONTRACT_APP_LEVEL: 'Contract App Level',
+});
+
+export const buildDataContractDetail = (
+  dataContract: V1_DataContract,
+  options?: ContractDetailOptions | undefined,
+): GridItemDetail[] => {
+  const applicationIdUrlCallBack = options?.openApplicationIdHandler;
+  const directoryUrl = options?.openDirectoryHandler;
+  const openContractHandler = options?.externalReference?.openContractHandler;
+  const contractDetails = [
+    {
+      name: CONTRACT_GRID_NAME.CONTRACT_ID,
+      value: dataContract.guid,
+      onClick: openContractHandler
+        ? () => openContractHandler(dataContract.guid)
+        : undefined,
+    },
+    {
+      name: CONTRACT_GRID_NAME.CONTRACT_DESCRIPTION,
+      value: dataContract.description,
+    },
+    {
+      name: CONTRACT_GRID_NAME.CONTRACT_VERSION,
+      value: dataContract.version,
+    },
+    {
+      name: CONTRACT_GRID_NAME.CONTRACT_STATE,
+      value: prettyCONSTName(dataContract.state),
+    },
+  ];
+  const accessPointGroupRef = dataContract.resource;
+  let dataProductDetails: GridItemDetail[] = [];
+  if (accessPointGroupRef instanceof V1_AccessPointGroupReference) {
+    dataProductDetails = [
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_DATA_PRODUCT_ID,
+        value: accessPointGroupRef.dataProduct.guid,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_DATA_PRODUCT,
+        value: accessPointGroupRef.dataProduct.name,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_DATA_PRODUCT_DID,
+        value: accessPointGroupRef.dataProduct.owner.appDirId,
+        onClick: applicationIdUrlCallBack
+          ? () =>
+              applicationIdUrlCallBack(
+                accessPointGroupRef.dataProduct.owner.appDirId.toString(),
+              )
+          : undefined,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_ACCESS_GROUP,
+        value: accessPointGroupRef.accessPointGroup,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_ACCESS_POINTS,
+        value: accessPointGroupRef.dataProduct.accessPoints
+          .map((ap) => ap.name)
+          .join(', '),
+      },
+    ];
+  }
+  const org = dataContract.consumer;
+  let orgDetails: GridItemDetail[] = [];
+  if (org instanceof V1_AppDirOrganizationalScope) {
+    orgDetails = convertMutilGridItemDetail(
+      org.appDirNode.map((value) => [
+        {
+          name: CONTRACT_GRID_NAME.CONTRACT_APP_DID,
+          value: value.appDirId.toString(),
+        },
+        {
+          name: CONTRACT_GRID_NAME.CONTRACT_APP_LEVEL,
+          value: value.level.toString(),
+        },
+      ]),
+    );
+  } else if (org instanceof V1_AdhocTeam) {
+    orgDetails = convertMutilGridItemDetail(
+      org.users.map((user) => {
+        return [
+          {
+            name: CONTRACT_GRID_NAME.CONTRACT_CONSUMER_NAME,
+            value: user.name,
+            onClick: directoryUrl ? () => directoryUrl(user.name) : undefined,
+          },
+        ];
+      }),
+    );
+  }
+  const contractMembers = convertMutilGridItemDetail(
+    dataContract.members.map((member) => [
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_MEMBER_ID,
+        value: member.guid,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_MEMBER_NAME,
+        value: member.user.name,
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_MEMBER_TYPE,
+        value: member.user.userType.toString(),
+      },
+      {
+        name: CONTRACT_GRID_NAME.CONTRACT_MEMBER_STATUS,
+        value: member.status.toString(),
+      },
+    ]),
+  );
+  return [
+    ...contractDetails,
+    ...dataProductDetails,
+    ...orgDetails,
+    ...contractMembers,
+  ];
+};
+
+const getGridInfoFromTaskStatus = (
+  status: V1_UserApprovalStatus,
+): GridTiemStatus | undefined => {
+  switch (status) {
+    case V1_UserApprovalStatus.APPROVED:
+      return GridTiemStatus.SUCCESS;
+    case V1_UserApprovalStatus.DENIED:
+      return GridTiemStatus.ERROR;
+    case V1_UserApprovalStatus.PENDING:
+      return GridTiemStatus.INFO;
+    default:
+      return undefined;
+  }
+};
+
+export const TYPE_GRID_ITEM = Object.freeze({
+  TASK_ID: 'Task ID',
+  TASK_STATUS: 'Task Status',
+  TASK_CONSUMER: 'Task Consumer',
+  TASK_ASSIGNEE: 'Task Assignee',
+});
+
+export const buildTaskGridItemDetail = (
+  task: V1_ContractUserEventRecord,
+  assignees?: string[] | undefined,
+  contract?: V1_DataContract | undefined,
+  openContractHandler?: ((id: string) => void) | undefined,
+  openDirectoryHandler?: ((id: string) => void) | undefined,
+  openApplicationIdHandler?: ((user: string) => void) | undefined,
+): GridItemDetail[] => {
+  const taskAssignees = convertMutilGridItemDetail(
+    assignees?.map((name) => [
+      {
+        name: TYPE_GRID_ITEM.TASK_ASSIGNEE,
+        value: name,
+        onClick: openDirectoryHandler
+          ? () => openDirectoryHandler(name)
+          : undefined,
+      },
+    ]) ?? [],
+  );
+  return [
+    {
+      name: TYPE_GRID_ITEM.TASK_ID,
+      value: task.taskId,
+    },
+    {
+      name: TYPE_GRID_ITEM.TASK_STATUS,
+      value: task.status.toString(),
+      status: getGridInfoFromTaskStatus(task.status),
+    },
+    {
+      name: TYPE_GRID_ITEM.TASK_CONSUMER,
+      value: task.consumer,
+      onClick: openDirectoryHandler
+        ? () => openDirectoryHandler(task.consumer)
+        : undefined,
+    },
+    ...taskAssignees,
+    ...(contract && openContractHandler
+      ? buildDataContractDetail(contract, {
+          openDirectoryHandler,
+          openApplicationIdHandler,
+          externalReference: {
+            openContractHandler,
+          },
+        })
+      : []),
+  ];
+};

package/src/stores/lakehouse/entitlements/{LakehouseEntitlementsMainViewState.ts → EntitlementsDashboardState.ts}

@@ -39,7 +39,7 @@ import {
 } from './LakehouseEntitlementsStore.js';
 import { LakehouseViewerState } from './LakehouseViewerState.js';
 
-export class LakehouseEntitlementsMainViewState extends LakehouseViewerState {
+export class EntitlementsDashboardState extends LakehouseViewerState {
   pendingTasks: V1_ContractUserEventRecord[] | undefined;
   pendingContracts: V1_UserPendingContractsRecord[] | undefined;
   changingState = ActionState.create();
@@ -67,7 +67,6 @@ export class LakehouseEntitlementsMainViewState extends LakehouseViewerState {
         TEST_USER,
         token,
       )) as PlainObject<V1_PendingTasksRespond>;
-
       const pendingContracts =
         (yield this.state.lakehouseServerClient.getPendingContracts(
           TEST_USER2,
@@ -111,8 +110,14 @@ export class LakehouseEntitlementsMainViewState extends LakehouseViewerState {
       }
       task.status = change.status;
       this.setPendingTasks([...(this.pendingTasks ?? [])]);
+      this.state.applicationStore.notificationService.notifySuccess(
+        `Task has been Approved`,
+      );
     } catch (error) {
       assertErrorThrown(error);
+      this.state.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
     } finally {
       this.changingState.complete();
       this.changingState.setMessage(undefined);
@@ -125,7 +130,11 @@ export class LakehouseEntitlementsMainViewState extends LakehouseViewerState {
   ): GeneratorFn<void> {
     try {
       this.changingState.inProgress();
-      this.changingState.setMessage('Denying Task');
+      this.state.applicationStore.alertService.setBlockingAlert({
+        message: 'Denying Task',
+        prompt: 'Denying task...',
+        showLoading: true,
+      });
       const response = (yield this.state.lakehouseServerClient.denyTask(
         task.taskId,
         token,
@@ -141,11 +150,18 @@ export class LakehouseEntitlementsMainViewState extends LakehouseViewerState {
       }
       task.status = change.status;
       this.setPendingTasks([...(this.pendingTasks ?? [])]);
+      this.state.applicationStore.notificationService.notifySuccess(
+        `Task has been denied`,
+      );
     } catch (error) {
       assertErrorThrown(error);
+      this.state.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
     } finally {
       this.changingState.complete();
       this.changingState.setMessage(undefined);
+      this.state.applicationStore.alertService.setBlockingAlert(undefined);
     }
   }
 }

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

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type V1_ContractUserEventRecord,
+  type V1_PendingTasksRespond,
+  type V1_DataContract,
+  V1_deserializeTaskResponse,
+} from '@finos/legend-graph';
+import { type LakehouseEntitlementsStore } from './LakehouseEntitlementsStore.js';
+import { LakehouseViewerState } from './LakehouseViewerState.js';
+import {
+  assertErrorThrown,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { action, computed, flow, makeObservable, observable } from 'mobx';
+import {
+  buildDataContractDetail,
+  buildTaskGridItemDetail,
+  convertMutilGridItemDetail,
+  type GridItemDetail,
+} from '../LakehouseUtils.js';
+
+export class EntitlementsDataContractViewerState extends LakehouseViewerState {
+  readonly value: V1_DataContract;
+  associatedTasks: V1_ContractUserEventRecord[] | undefined;
+
+  constructor(value: V1_DataContract, state: LakehouseEntitlementsStore) {
+    super(state);
+    this.value = value;
+    makeObservable(this, {
+      associatedTasks: observable,
+      setAssociatedTasks: action,
+      init: flow,
+      tasksDetails: computed,
+    });
+  }
+
+  get contractDetails(): GridItemDetail[] {
+    return [
+      ...buildDataContractDetail(this.value, {
+        openDirectoryHandler: this.state.directoryCallBack,
+        openApplicationIdHandler: this.state.applicationCallBack,
+      }),
+      ...this.tasksDetails,
+    ];
+  }
+
+  get tasksDetails(): GridItemDetail[] {
+    return convertMutilGridItemDetail(
+      this.associatedTasks?.map((task) =>
+        buildTaskGridItemDetail(
+          task,
+          [],
+          undefined,
+          undefined,
+          this.state.directoryCallBack,
+          this.state.applicationCallBack,
+        ),
+      ) ?? [],
+    ).map((e) => {
+      e.name = `Contract ${e.name}`;
+      return e;
+    });
+  }
+
+  setAssociatedTasks(
+    associatedTasks: V1_ContractUserEventRecord[] | undefined,
+  ): void {
+    this.associatedTasks = associatedTasks;
+  }
+
+  *init(token: string | undefined): GeneratorFn<void> {
+    try {
+      this.setAssociatedTasks(undefined);
+      const pendingContracts =
+        (yield this.state.lakehouseServerClient.getContractTasks(
+          this.value.guid,
+          token,
+        )) as PlainObject<V1_PendingTasksRespond>;
+      const tasks = V1_deserializeTaskResponse(pendingContracts);
+      this.setAssociatedTasks(tasks.map((e) => e.rec));
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+  }
+}

package/src/stores/lakehouse/entitlements/{DataContractTaskState.ts → EntitlementsTaskViewerState.ts}

@@ -15,6 +15,7 @@
  */
 
 import {
+  ActionState,
   assertErrorThrown,
   type GeneratorFn,
   type PlainObject,
@@ -30,30 +31,37 @@ import {
   type V1_DataContractsRecord,
   type V1_PendingTasksRespond,
   V1_pendingTasksRespondModelSchema,
+  type V1_UserPendingContractsRecord,
+  type V1_TaskMetadata,
 } from '@finos/legend-graph';
 import { makeObservable, flow, observable, flowResult, action } from 'mobx';
 import {
-  type GridItemDetail,
   type LakehouseEntitlementsStore,
   TEST_USER,
 } from './LakehouseEntitlementsStore.js';
-import { buildDataContractDetail } from './DataContractState.js';
 import { LakehouseViewerState } from './LakehouseViewerState.js';
+import {
+  buildTaskGridItemDetail,
+  type GridItemDetail,
+} from '../LakehouseUtils.js';
+import { generateLakehouseContractPath } from '../../../__lib__/LegendMarketplaceNavigation.js';
 
-export class DataContractTaskState extends LakehouseViewerState {
+export class EntitlementsTaskViewerState extends LakehouseViewerState {
   readonly value: V1_ContractUserEventRecord;
+  readonly approvalStatus = ActionState.create();
   canApprove: boolean | undefined;
   dataContract: V1_DataContract | undefined;
-
-  constructor(
-    value: V1_ContractUserEventRecord,
-    state: LakehouseEntitlementsStore,
-  ) {
+  pendingAssociatedContractEvent: V1_UserPendingContractsRecord[] | undefined;
+  changingTaskState = ActionState.create();
+  taskAssignees: string[] | undefined;
+  constructor(value: V1_TaskMetadata, state: LakehouseEntitlementsStore) {
     super(state);
-    this.value = value;
+    this.value = value.rec;
+    this.taskAssignees = value.assignees;
     makeObservable(this, {
-      value: observable,
       canApprove: observable,
+      pendingAssociatedContractEvent: observable,
+      setPendingAssociatedContractEvent: action,
       setCanApprove: action,
       approve: flow,
       deny: flow,
@@ -61,6 +69,7 @@ export class DataContractTaskState extends LakehouseViewerState {
       calculateApprovalRights: flow,
       fetchContract: flow,
       dataContract: observable,
+      taskAssignees: observable,
     });
     this.observeContract();
   }
@@ -69,6 +78,12 @@ export class DataContractTaskState extends LakehouseViewerState {
     return this.value.taskId;
   }
 
+  setPendingAssociatedContractEvent(
+    pendingAssociatedContractEvent: V1_UserPendingContractsRecord[] | undefined,
+  ): void {
+    this.pendingAssociatedContractEvent = pendingAssociatedContractEvent;
+  }
+
   *init(token: string | undefined): GeneratorFn<void> {
     flowResult(this.calculateApprovalRights(token)).catch(
       this.state.applicationStore.alertUnhandledError,
@@ -90,6 +105,7 @@ export class DataContractTaskState extends LakehouseViewerState {
 
   *approve(token: string | undefined): GeneratorFn<void> {
     try {
+      this.approvalStatus.inProgress();
       const response = (yield this.state.lakehouseServerClient.approveTask(
         this.value.taskId,
         token,
@@ -99,19 +115,34 @@ export class DataContractTaskState extends LakehouseViewerState {
         response,
       );
       if (change.errorMessage) {
+        this.approvalStatus.fail();
         throw new Error(
           `Unable to approve task: ${this.value.taskId}: ${change.errorMessage}`,
         );
       }
       this.value.status = change.status;
       this.setCanApprove(false);
+      this.approvalStatus.pass();
+      this.state.applicationStore.notificationService.notifySuccess(
+        'Approval succeeded',
+      );
     } catch (error) {
+      this.approvalStatus.fail();
       assertErrorThrown(error);
+      this.state.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
     }
   }
 
   *deny(token: string | undefined): GeneratorFn<void> {
     try {
+      this.changingTaskState.inProgress();
+      this.state.applicationStore.alertService.setBlockingAlert({
+        message: 'Denying Task',
+        prompt: 'Denying task...',
+        showLoading: true,
+      });
       const response = (yield this.state.lakehouseServerClient.denyTask(
         this.value.taskId,
         token,
@@ -127,8 +158,18 @@ export class DataContractTaskState extends LakehouseViewerState {
       }
       this.value.status = change.status;
       this.setCanApprove(false);
+      this.state.applicationStore.notificationService.notifySuccess(
+        `Task has been denied`,
+      );
     } catch (error) {
       assertErrorThrown(error);
+      this.state.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
+    } finally {
+      this.changingTaskState.complete();
+      this.changingTaskState.setMessage(undefined);
+      this.state.applicationStore.alertService.setBlockingAlert(undefined);
     }
   }
 
@@ -170,20 +211,17 @@ export class DataContractTaskState extends LakehouseViewerState {
   }
 
   get taskDetails(): GridItemDetail[] {
-    return [
-      {
-        name: 'Task ID',
-        value: this.value.taskId,
-      },
-      {
-        name: 'Task Status',
-        value: this.value.status.toString(),
-      },
-      {
-        name: 'Task Consumer',
-        value: this.value.consumer,
+    return buildTaskGridItemDetail(
+      this.value,
+      this.taskAssignees,
+      this.dataContract,
+      (id: string): void => {
+        this.state.applicationStore.navigationService.navigator.updateCurrentLocation(
+          generateLakehouseContractPath(id),
+        );
       },
-      ...(this.dataContract ? buildDataContractDetail(this.dataContract) : []),
-    ];
+      this.state.directoryCallBack,
+      this.state.applicationCallBack,
+    );
   }
 }