@finos/legend-application-marketplace 0.0.19 → 0.0.21

package/src/stores/lakehouse/DataProductViewerState.ts

@@ -19,7 +19,6 @@ import {
   type GenericLegendApplicationStore,
   type NavigationZone,
 } from '@finos/legend-application';
-
 import {
   type DataProductArtifactGeneration,
   type V1_DataContract,
@@ -28,10 +27,15 @@ import {
   V1_AppDirLevel,
   V1_AppDirNode,
   V1_AppDirNodeModelSchema,
-  V1_DataContractsRecordModelSchema,
   type GraphData,
   type GraphManagerState,
   type V1_DataProduct,
+  type V1_AccessPointGroup,
+  V1_User,
+  V1_UserType,
+  V1_AdhocTeam,
+  V1_AdhocTeamModelSchema,
+  V1_DataContractsRecordModelSchemaToContracts,
 } from '@finos/legend-graph';
 import type { VersionedProjectData } from '@finos/legend-server-depot';
 import { action, computed, flow, makeObservable, observable } from 'mobx';
@@ -45,13 +49,25 @@ import {
 } from './DataProductViewerNavigation.js';
 import { DataProductDataAccessState } from './DataProductDataAccessState.js';
 import {
+  ActionState,
   assertErrorThrown,
   guaranteeNonEmptyString,
+  guaranteeNonNullable,
   type GeneratorFn,
   type PlainObject,
 } from '@finos/legend-shared';
 import type { LakehouseContractServerClient } from '../LakehouseContractServerClient.js';
-import { deserialize, serialize } from 'serializr';
+import { serialize } from 'serializr';
+import { dataContractContainsDataProduct } from './LakehouseUtils.js';
+
+const buildAdhocUser = (user: string): V1_AdhocTeam => {
+  const _user = new V1_User();
+  _user.name = user;
+  _user.userType = V1_UserType.WORKFORCE_USER;
+  const _adhocTeam = new V1_AdhocTeam();
+  _adhocTeam.users = [_user];
+  return _adhocTeam;
+};
 
 export class DataProductViewerState {
   readonly applicationStore: GenericLegendApplicationStore;
@@ -72,6 +88,10 @@ export class DataProductViewerState {
   accessState: DataProductDataAccessState;
   generation: DataProductArtifactGeneration | undefined;
   associatedContracts: V1_DataContract[] | undefined;
+  dataContractAccessPointGroup: V1_AccessPointGroup | undefined;
+  // actions
+
+  creatingContractState = ActionState.create();
 
   constructor(
     applicationStore: GenericLegendApplicationStore,
@@ -91,9 +111,13 @@ export class DataProductViewerState {
       setCurrentActivity: action,
       isVerified: computed,
       accessState: observable,
-      init: flow,
+      fetchContracts: flow,
       associatedContracts: observable,
+      dataContractAccessPointGroup: observable,
+      setDataContractAccessPointGroup: action,
       setAssociatedContracts: action,
+      create: flow,
+      creatingContractState: observable,
     });
 
     this.applicationStore = applicationStore;
@@ -114,49 +138,82 @@ export class DataProductViewerState {
     this.associatedContracts = val;
   }
 
-  *init(token: string | undefined): GeneratorFn<void> {
+  setDataContractAccessPointGroup(val: V1_AccessPointGroup | undefined) {
+    this.dataContractAccessPointGroup = val;
+  }
+
+  *fetchContracts(token: string | undefined): GeneratorFn<void> {
     try {
       const did = guaranteeNonEmptyString(
         this.generation?.dataProduct.deploymentId,
         'did required to get contracts',
       );
-
       const didNode = new V1_AppDirNode();
       didNode.appDirId = Number(did);
       didNode.level = V1_AppDirLevel.DEPLOYMENT;
       const _contracts = (yield this.lakeServerClient.getDataContractsFromDID(
-        serialize(V1_AppDirNodeModelSchema, didNode),
+        [serialize(V1_AppDirNodeModelSchema, didNode)],
         token,
       )) as PlainObject<V1_DataContractsRecord>;
-
-      const dataProductContracts = deserialize(
-        V1_DataContractsRecordModelSchema,
+      const dataProductContracts = V1_DataContractsRecordModelSchemaToContracts(
         _contracts,
-      )
-        .dataContracts.map((e) => e.dataContract)
-        .filter((_contract) => {
-          const _resource = _contract.resource;
-          if (
-            _resource instanceof V1_AccessPointGroupReference &&
-            this.deploymentId
-          ) {
-            const isDID =
-              Number(this.deploymentId) ===
-              _resource.dataProduct.owner.appDirId;
-            const isName = _resource.dataProduct.name === this.product.name;
-            const hasGroup = this.product.accessPointGroups
-              .map((e) => e.id)
-              .includes(_resource.accessPointGroup);
-            return isDID && isName && hasGroup;
-          }
-          return false;
-        });
+      ).filter((_contract) =>
+        dataContractContainsDataProduct(
+          this.product,
+          this.deploymentId,
+          _contract,
+        ),
+      );
       this.setAssociatedContracts(dataProductContracts);
+      this.accessState.accessGroupStates.forEach((e) =>
+        e.handleDataProductContracts(dataProductContracts),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.accessState.viewerState.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
+    }
+  }
+
+  *create(
+    description: string,
+    group: V1_AccessPointGroup,
+    token: string | undefined,
+  ): GeneratorFn<void> {
+    try {
+      this.creatingContractState.inProgress();
+      const request: PlainObject<V1_DataContractsRecord> = {
+        description,
+        product: guaranteeNonNullable(this.generation?.content),
+        accessPointGroup: group.id,
+        consumer: serialize(
+          V1_AdhocTeamModelSchema,
+          buildAdhocUser(this.applicationStore.identityService.currentUser),
+        ),
+      };
+      const contracts = V1_DataContractsRecordModelSchemaToContracts(
+        (yield this.lakeServerClient.createContract(
+          request,
+          token,
+        )) as unknown as PlainObject<V1_DataContractsRecord>,
+      );
+      const associatedContracts = contracts[0];
+      const findGroup = this.accessState.accessGroupStates.find(
+        (e) => e.group === group,
+      );
+      findGroup?.setAssociatedContract(associatedContracts);
+      this.setDataContractAccessPointGroup(undefined);
+      this.applicationStore.notificationService.notifySuccess(
+        `Contract created, please go to contract view for pending tasks`,
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.accessState.viewerState.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+    } finally {
+      this.creatingContractState.complete();
     }
   }
 

package/src/stores/lakehouse/LakehouseUtils.ts

@@ -0,0 +1,345 @@
+/**
+ * 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_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,
+  V1_ContractState.CLOSED,
+];
+
+const inProgressContractState = [
+  V1_ContractState.PENDING_DATA_OWNER_APPROVAL,
+  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,
+  dataContract: V1_DataContract,
+): boolean => {
+  if (inValidContractState.includes(dataContract.state)) {
+    return false;
+  }
+  const contractResource = dataContract.resource;
+  if (
+    contractResource instanceof V1_AccessPointGroupReference &&
+    dataProdcutDeploymentID
+  ) {
+    const sameDID =
+      Number(dataProdcutDeploymentID) ===
+      contractResource.dataProduct.owner.appDirId;
+    // revisit name
+    const isName = contractResource.dataProduct.name === dataProduct.name;
+    const hasGroup = dataProduct.accessPointGroups
+      .map((e) => e.id)
+      .includes(contractResource.accessPointGroup);
+    return sameDID && isName && hasGroup;
+  }
+
+  return false;
+};
+
+// Assume contract already part of data product
+export const dataContractContainsAccessGroup = (
+  group: V1_AccessPointGroup,
+  dataContract: V1_DataContract,
+): boolean => {
+  const contractResource = dataContract.resource;
+  if (contractResource instanceof V1_AccessPointGroupReference) {
+    return contractResource.accessPointGroup === group.id;
+  }
+  return false;
+};
+
+export const isMemberOfContract = (
+  user: string,
+  contract: V1_DataContract,
+): boolean => {
+  const consumer = contract.consumer;
+  if (consumer instanceof V1_AdhocTeam) {
+    return consumer.users.some((e) => e.name === user);
+  }
+  return false;
+};
+
+export const isContractCompleted = (contract: V1_DataContract): boolean => {
+  return contract.state === V1_ContractState.COMPLETED;
+};
+
+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/MarketplaceLakehouseStore.ts

@@ -272,13 +272,16 @@ export class MarketplaceLakehouseStore implements CommandRegistrar {
         resolveVersion(projectData.versionId),
         ARTIFACT_GENERATION_DAT_PRODUCT_KEY,
       )) as StoredFileGeneration[];
-      const generation = files.filter((e) => e.path === v1DataProduct.path)[0]
+      const fileGen = files.filter((e) => e.path === v1DataProduct.path)[0]
         ?.file.content;
-      const parsed = generation
-        ? DataProductArtifactGeneration.serialization.fromJson(
-            JSON.parse(generation),
-          )
-        : undefined;
+      let parsed: DataProductArtifactGeneration | undefined = undefined;
+      if (fileGen) {
+        const content: PlainObject = JSON.parse(fileGen) as PlainObject;
+        const gen =
+          DataProductArtifactGeneration.serialization.fromJson(content);
+        gen.content = content;
+        parsed = gen;
+      }
       const stateViewer = new DataProductViewerState(
         this.applicationStore,
         new GraphManagerState(
@@ -325,6 +328,7 @@ export class MarketplaceLakehouseStore implements CommandRegistrar {
         },
       );
       this.setDataProductViewerState(stateViewer);
+      stateViewer.fetchContracts(auth.user?.access_token);
       this.loadingProductsState.complete();
     } catch (error) {
       assertErrorThrown(error);