@finos/legend-application-marketplace 0.0.19 → 0.0.21

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

@@ -0,0 +1,167 @@
+/**
+ * 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 {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { deserialize } from 'serializr';
+import {
+  type V1_ContractUserEventRecord,
+  type V1_TaskStatusChangeResponse,
+  V1_TaskStatusChangeResponseModelSchema,
+  type V1_PendingTasksRespond,
+  type V1_UserPendingContractsRecord,
+  type V1_UserPendingContractsResponse,
+  type V1_TaskStatus,
+  V1_pendingTasksRespondModelSchema,
+} from '@finos/legend-graph';
+import { makeObservable, flow, observable, action } from 'mobx';
+import {
+  TEST_USER,
+  TEST_USER2,
+  type LakehouseEntitlementsStore,
+} from './LakehouseEntitlementsStore.js';
+import { LakehouseViewerState } from './LakehouseViewerState.js';
+
+export class EntitlementsDashboardState extends LakehouseViewerState {
+  pendingTasks: V1_ContractUserEventRecord[] | undefined;
+  pendingContracts: V1_UserPendingContractsRecord[] | undefined;
+  changingState = ActionState.create();
+
+  constructor(state: LakehouseEntitlementsStore) {
+    super(state);
+    makeObservable(this, {
+      pendingTasks: observable,
+      setPendingTasks: action,
+      changingState: observable,
+      pendingContracts: observable,
+      initializationState: observable,
+      approve: flow,
+      setPendingContracts: action,
+      init: flow,
+      deny: flow,
+    });
+  }
+
+  *init(token: string | undefined): GeneratorFn<void> {
+    try {
+      this.setPendingContracts(undefined);
+      this.setPendingTasks(undefined);
+      const rawTasks = (yield this.state.lakehouseServerClient.getPendingTasks(
+        TEST_USER,
+        token,
+      )) as PlainObject<V1_PendingTasksRespond>;
+      const pendingContracts =
+        (yield this.state.lakehouseServerClient.getPendingContracts(
+          TEST_USER2,
+          token,
+        )) as V1_UserPendingContractsResponse;
+      this.setPendingContracts(pendingContracts.records ?? []);
+      const tasks = deserialize(V1_pendingTasksRespondModelSchema, rawTasks);
+      this.setPendingTasks([...tasks.dataOwner, ...tasks.privilegeManager]);
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+  }
+
+  setPendingTasks(val: V1_ContractUserEventRecord[] | undefined): void {
+    this.pendingTasks = val;
+  }
+
+  setPendingContracts(val: V1_UserPendingContractsRecord[] | undefined): void {
+    this.pendingContracts = val;
+  }
+
+  *approve(
+    task: V1_ContractUserEventRecord,
+    token: string | undefined,
+  ): GeneratorFn<void> {
+    try {
+      this.changingState.inProgress();
+      this.changingState.setMessage('Approving Task');
+      const response = (yield this.state.lakehouseServerClient.approveTask(
+        task.taskId,
+        token,
+      )) as PlainObject<V1_TaskStatusChangeResponse>;
+      const change = deserialize(
+        V1_TaskStatusChangeResponseModelSchema,
+        response,
+      );
+      if (change.errorMessage) {
+        throw new Error(
+          `Unable to approve task: ${task.taskId}: ${change.errorMessage}`,
+        );
+      }
+      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);
+    }
+  }
+
+  *deny(
+    task: V1_ContractUserEventRecord,
+    token: string | undefined,
+  ): GeneratorFn<void> {
+    try {
+      this.changingState.inProgress();
+      this.state.applicationStore.alertService.setBlockingAlert({
+        message: 'Denying Task',
+        prompt: 'Denying task...',
+        showLoading: true,
+      });
+      const response = (yield this.state.lakehouseServerClient.denyTask(
+        task.taskId,
+        token,
+      )) as PlainObject<V1_TaskStatus>;
+      const change = deserialize(
+        V1_TaskStatusChangeResponseModelSchema,
+        response,
+      );
+      if (change.errorMessage) {
+        throw new Error(
+          `Unable to deny task: ${task.taskId}: ${change.errorMessage}`,
+        );
+      }
+      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/EntitlementsTaskViewerState.ts

@@ -0,0 +1,227 @@
+/**
+ * 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 {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { deserialize } from 'serializr';
+import {
+  type V1_ContractUserEventRecord,
+  type V1_TaskStatusChangeResponse,
+  V1_TaskStatusChangeResponseModelSchema,
+  type V1_TaskStatus,
+  type V1_DataContract,
+  V1_DataContractsRecordModelSchema,
+  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 LakehouseEntitlementsStore,
+  TEST_USER,
+} from './LakehouseEntitlementsStore.js';
+import { LakehouseViewerState } from './LakehouseViewerState.js';
+import {
+  buildTaskGridItemDetail,
+  type GridItemDetail,
+} from '../LakehouseUtils.js';
+import { generateLakehouseContractPath } from '../../../__lib__/LegendMarketplaceNavigation.js';
+
+export class EntitlementsTaskViewerState extends LakehouseViewerState {
+  readonly value: V1_ContractUserEventRecord;
+  readonly approvalStatus = ActionState.create();
+  canApprove: boolean | undefined;
+  dataContract: V1_DataContract | undefined;
+  pendingAssociatedContractEvent: V1_UserPendingContractsRecord[] | undefined;
+  changingTaskState = ActionState.create();
+  taskAssignees: string[] | undefined;
+  constructor(value: V1_TaskMetadata, state: LakehouseEntitlementsStore) {
+    super(state);
+    this.value = value.rec;
+    this.taskAssignees = value.assignees;
+    makeObservable(this, {
+      canApprove: observable,
+      pendingAssociatedContractEvent: observable,
+      setPendingAssociatedContractEvent: action,
+      setCanApprove: action,
+      approve: flow,
+      deny: flow,
+      init: flow,
+      calculateApprovalRights: flow,
+      fetchContract: flow,
+      dataContract: observable,
+      taskAssignees: observable,
+    });
+    this.observeContract();
+  }
+
+  get id(): string {
+    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,
+    );
+    flowResult(this.fetchContract(token)).catch(
+      this.state.applicationStore.alertUnhandledError,
+    );
+  }
+
+  setCanApprove(val: boolean | undefined): void {
+    this.canApprove = val;
+  }
+
+  observeContract(): void {
+    makeObservable(this.value, {
+      status: observable,
+    });
+  }
+
+  *approve(token: string | undefined): GeneratorFn<void> {
+    try {
+      this.approvalStatus.inProgress();
+      const response = (yield this.state.lakehouseServerClient.approveTask(
+        this.value.taskId,
+        token,
+      )) as PlainObject<V1_TaskStatusChangeResponse>;
+      const change = deserialize(
+        V1_TaskStatusChangeResponseModelSchema,
+        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,
+      )) as PlainObject<V1_TaskStatus>;
+      const change = deserialize(
+        V1_TaskStatusChangeResponseModelSchema,
+        response,
+      );
+      if (change.errorMessage) {
+        throw new Error(
+          `Unable to deny task: ${this.value.taskId}: ${change.errorMessage}`,
+        );
+      }
+      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);
+    }
+  }
+
+  *calculateApprovalRights(token: string | undefined): GeneratorFn<void> {
+    this.canApprove = undefined;
+    try {
+      const rawTasks = (yield this.state.lakehouseServerClient.getPendingTasks(
+        TEST_USER,
+        token,
+      )) as PlainObject<V1_PendingTasksRespond>;
+      const tasks = deserialize(V1_pendingTasksRespondModelSchema, rawTasks);
+      const allTasks = [...tasks.dataOwner, ...tasks.privilegeManager];
+      const canApprove = Boolean(
+        allTasks.find((e) => e.taskId === this.value.taskId),
+      );
+      this.setCanApprove(canApprove);
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+  }
+
+  *fetchContract(token: string | undefined): GeneratorFn<void> {
+    try {
+      const contractId = this.value.dataContractId;
+      const dataContracts =
+        (yield this.state.lakehouseServerClient.getDataContract(
+          contractId,
+          token,
+        )) as PlainObject<V1_DataContractsRecord>;
+
+      const dataContract = deserialize(
+        V1_DataContractsRecordModelSchema,
+        dataContracts,
+      ).dataContracts[0]?.dataContract;
+      this.dataContract = dataContract;
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+  }
+
+  get taskDetails(): GridItemDetail[] {
+    return buildTaskGridItemDetail(
+      this.value,
+      this.taskAssignees,
+      this.dataContract,
+      (id: string): void => {
+        this.state.applicationStore.navigationService.navigator.updateCurrentLocation(
+          generateLakehouseContractPath(id),
+        );
+      },
+      this.state.directoryCallBack,
+      this.state.applicationCallBack,
+    );
+  }
+}