@finos/legend-application-marketplace 0.1.54 → 0.1.56

package/src/application/providers/LegendMarketplaceFrameworkProvider.tsx

@@ -19,9 +19,7 @@ import { guaranteeNonNullable } from '@finos/legend-shared';
 import { useLocalObservable } from 'mobx-react-lite';
 import {
   ApplicationFrameworkProvider,
-  BlockingAlert,
   useApplicationStore,
-  NotificationManager,
 } from '@finos/legend-application';
 import {
   type LegendMarketplaceApplicationStore,
@@ -65,8 +63,8 @@ export const LegendMarketplaceFrameworkProvider: React.FC<{
   children: React.ReactNode;
 }> = ({ children }) => (
   <ApplicationFrameworkProvider
-    simple={true}
     enableTransitions={true}
+    disableVirtualAssistant={true}
     customFonts={[
       '"GS Sans"',
       'Roboto',
@@ -76,8 +74,6 @@ export const LegendMarketplaceFrameworkProvider: React.FC<{
       'sans-serif',
     ].join(',')}
   >
-    <BlockingAlert />
-    <NotificationManager />
     <LegendMarketplaceBaseStoreProvider>
       {children}
     </LegendMarketplaceBaseStoreProvider>

package/src/components/SearchBar/LegendMarketplaceSearchBar.tsx

@@ -27,6 +27,8 @@ import {
 import { clsx, SearchIcon, TuneIcon } from '@finos/legend-art';
 import { observer } from 'mobx-react-lite';
 import { LegendMarketplaceInfoTooltip } from '../InfoTooltip/LegendMarketplaceInfoTooltip.js';
+import { LegendMarketplaceTelemetryHelper } from '../../__lib__/LegendMarketplaceTelemetryHelper.js';
+import { useLegendMarketplaceBaseStore } from '../../application/providers/LegendMarketplaceFrameworkProvider.js';
 
 export interface Vendor {
   provider: string;
@@ -54,6 +56,7 @@ export const LegendMarketplaceSearchBar = observer(
       initialUseProducerSearch,
     } = props;
 
+    const applicationStore = useLegendMarketplaceBaseStore().applicationStore;
     const [searchQuery, setSearchQuery] = useState<string>(initialValue ?? '');
     const [useProducerSearch, setUseProducerSearch] = useState(
       initialUseProducerSearch ?? false,
@@ -117,6 +120,10 @@ export const LegendMarketplaceSearchBar = observer(
                     checked={useProducerSearch}
                     onChange={(event) => {
                       setUseProducerSearch(event.target.checked);
+                      LegendMarketplaceTelemetryHelper.logEvent_toggleProducerSearch(
+                        applicationStore.telemetryService,
+                        event.target.checked,
+                      );
                     }}
                   />
                 }

package/src/pages/Lakehouse/MarketplaceLakehouseHome.tsx

@@ -63,6 +63,10 @@ export const MarketplaceLakehouseHome = observer(() => {
   >([]);
   const [loading, setLoading] = useState(false);
 
+  useEffect(() => {
+    LegendMarketplaceTelemetryHelper.clearSearchSession();
+  }, []);
+
   const [activeIndex, setActiveIndex] = useState(0);
   useEffect(() => {
     const loadDataProducts = async (): Promise<void> => {

package/src/pages/Lakehouse/admin/LakehouseAdminContractsDashboard.tsx

@@ -35,8 +35,8 @@ import {
   EntitlementsDataContractViewerState,
 } from '@finos/legend-extension-dsl-data-product';
 import {
+  generateContractPagePath,
   generateLakehouseDataProductPath,
-  generateLakehouseTaskPath,
 } from '../../../__lib__/LegendMarketplaceNavigation.js';
 
 export const LakehouseAdminContractsDashboard = observer(
@@ -143,9 +143,9 @@ export const LakehouseAdminContractsDashboard = observer(
               )
             }
             onRefresh={() => adminStore.refresh()}
-            getContractTaskUrl={(taskId: string) =>
+            getContractTaskUrl={(contractId: string, taskId: string) =>
               adminStore.legendMarketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
-                generateLakehouseTaskPath(taskId),
+                generateContractPagePath(contractId, taskId),
               )
             }
             getDataProductUrl={(dataProductId: string, deploymentId: number) =>

package/src/pages/Lakehouse/entitlements/EntitlementsClosedContractsDashboard.tsx

@@ -56,8 +56,8 @@ import {
   UserRenderer,
 } from '@finos/legend-extension-dsl-data-product';
 import {
+  generateContractPagePath,
   generateLakehouseDataProductPath,
-  generateLakehouseTaskPath,
 } from '../../../__lib__/LegendMarketplaceNavigation.js';
 import type { LakehouseEntitlementsStore } from '../../../stores/lakehouse/entitlements/LakehouseEntitlementsStore.js';
 import { flowResult } from 'mobx';
@@ -323,6 +323,25 @@ export const EntitlementsClosedContractsDashboard = observer(
       [myClosedContracts, closedContractsForOthers, showForOthers],
     );
 
+    const getInitialUserForViewer = (): string | undefined => {
+      const currentUser =
+        dashboardState.lakehouseEntitlementsStore.applicationStore
+          .identityService.currentUser;
+      if (selectedContract && myClosedContractIds.has(selectedContract.guid)) {
+        return currentUser;
+      }
+      if (
+        selectedContract &&
+        selectedContract.consumer instanceof V1_AdhocTeam &&
+        selectedContract.consumer.users.some(
+          (user) => user.name === currentUser,
+        )
+      ) {
+        return currentUser;
+      }
+      return undefined;
+    };
+
     return (
       <Box className="marketplace-lakehouse-entitlements__completed-contracts">
         <Box className="marketplace-lakehouse-entitlements__completed-contracts__action-btns">
@@ -375,12 +394,7 @@ export const EntitlementsClosedContractsDashboard = observer(
                 marketplaceBaseStore.userSearchService,
               )
             }
-            initialSelectedUser={
-              myClosedContractIds.has(selectedContract.guid)
-                ? dashboardState.lakehouseEntitlementsStore.applicationStore
-                    .identityService.currentUser
-                : undefined
-            }
+            initialSelectedUser={getInitialUserForViewer()}
             onRefresh={async () => {
               await flowResult(
                 dashboardState.updateContract(
@@ -389,9 +403,9 @@ export const EntitlementsClosedContractsDashboard = observer(
                 ),
               );
             }}
-            getContractTaskUrl={(taskId: string) =>
+            getContractTaskUrl={(contractId: string, taskId: string) =>
               marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
-                generateLakehouseTaskPath(taskId),
+                generateContractPagePath(contractId, taskId),
               )
             }
             getDataProductUrl={(dataProductId: string, deploymentId: number) =>

package/src/pages/Lakehouse/entitlements/EntitlementsPendingContractsDashboard.tsx

@@ -55,7 +55,7 @@ import {
   EntitlementsDataContractViewerState,
 } from '@finos/legend-extension-dsl-data-product';
 import {
-  generateLakehouseTaskPath,
+  generateContractPagePath,
   generateLakehouseDataProductPath,
 } from '../../../__lib__/LegendMarketplaceNavigation.js';
 import type { LakehouseEntitlementsStore } from '../../../stores/lakehouse/entitlements/LakehouseEntitlementsStore.js';
@@ -475,9 +475,9 @@ export const EntitlementsPendingContractsDashboard = observer(
                 ),
               );
             }}
-            getContractTaskUrl={(taskId: string) =>
+            getContractTaskUrl={(contractId: string, taskId: string) =>
               marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
-                generateLakehouseTaskPath(taskId),
+                generateContractPagePath(contractId, taskId),
               )
             }
             getDataProductUrl={(dataProductId: string, deploymentId: number) =>

package/src/pages/Lakehouse/entitlements/EntitlementsPendingTasksDashboard.tsx

@@ -69,7 +69,7 @@ import {
   EntitlementsDataContractViewerState,
 } from '@finos/legend-extension-dsl-data-product';
 import {
-  generateLakehouseTaskPath,
+  generateContractPagePath,
   generateLakehouseDataProductPath,
 } from '../../../__lib__/LegendMarketplaceNavigation.js';
 import {
@@ -855,9 +855,9 @@ export const EntitlementsPendingTasksDashboard = observer(
                 ),
               );
             }}
-            getContractTaskUrl={(taskId: string) =>
+            getContractTaskUrl={(contractId: string, taskId: string) =>
               marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
-                generateLakehouseTaskPath(taskId),
+                generateContractPagePath(contractId, taskId),
               )
             }
             getDataProductUrl={(dataProductId: string, deploymentId: number) =>

package/src/pages/Lakehouse/entitlements/LakehouseDataContract.tsx

@@ -0,0 +1,284 @@
+/**
+ * Copyright (c) 2026-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 { observer } from 'mobx-react-lite';
+import { withLegendMarketplaceProductViewerStore } from '../../../application/providers/LegendMarketplaceProductViewerStoreProvider.js';
+import { useParams } from '@finos/legend-application/browser';
+import {
+  generateContractPagePath,
+  generateLakehouseDataProductPath,
+  type LakehouseDataContractTaskPathParams,
+  LEGEND_MARKETPLACE_ROUTE_PATTERN_TOKEN,
+} from '../../../__lib__/LegendMarketplaceNavigation.js';
+import { assertErrorThrown, guaranteeNonNullable } from '@finos/legend-shared';
+import { useAuth } from 'react-oidc-context';
+import { LegendMarketplacePage } from '../../LegendMarketplacePage.js';
+import {
+  EntitlementsDataContractContent,
+  EntitlementsDataContractViewerState,
+} from '@finos/legend-extension-dsl-data-product';
+import { useEffect, useState } from 'react';
+import { useLegendMarketplaceBaseStore } from '../../../application/providers/LegendMarketplaceFrameworkProvider.js';
+import {
+  GraphManagerState,
+  V1_dataContractsResponseModelSchema,
+  V1_TaskStatusChangeResponseModelSchema,
+  V1_transformDataContractToLiteDatacontract,
+  V1_UserApprovalStatus,
+} from '@finos/legend-graph';
+import { deserialize } from 'serializr';
+import { Box, Button, Tooltip } from '@mui/material';
+import {
+  CubesLoadingIndicator,
+  CubesLoadingIndicatorIcon,
+} from '@finos/legend-art';
+
+export const LakehouseDataContractTask =
+  withLegendMarketplaceProductViewerStore(
+    observer(() => {
+      const marketplaceBaseStore = useLegendMarketplaceBaseStore();
+      const params = useParams<LakehouseDataContractTaskPathParams>();
+      const auth = useAuth();
+      const currentUser =
+        marketplaceBaseStore.applicationStore.identityService.currentUser;
+      const [contractViewerState, setContractViewerState] = useState<
+        EntitlementsDataContractViewerState | undefined
+      >(undefined);
+      const [isLoading, setIsLoading] = useState(false);
+
+      const contractId = guaranteeNonNullable(
+        params[LEGEND_MARKETPLACE_ROUTE_PATTERN_TOKEN.DATA_CONTRACT_ID],
+      );
+      const taskId = guaranteeNonNullable(
+        params[LEGEND_MARKETPLACE_ROUTE_PATTERN_TOKEN.DATA_CONTRACT_TASK_ID],
+      );
+
+      const associatedTask = contractViewerState?.associatedTasks?.find(
+        (task) => task.rec.taskId === taskId,
+      );
+      const isTaskPending =
+        associatedTask?.rec.status === V1_UserApprovalStatus.PENDING;
+      const userCanApprove =
+        isTaskPending && associatedTask.assignees.includes(currentUser);
+      const initialUser = associatedTask?.rec.consumer;
+
+      useEffect(() => {
+        const fetchAndInitializeContract = async () => {
+          try {
+            const rawContract =
+              await marketplaceBaseStore.lakehouseContractServerClient.getDataContract(
+                contractId,
+                false,
+                auth.user?.access_token,
+              );
+
+            const contractResponse = deserialize(
+              V1_dataContractsResponseModelSchema(
+                marketplaceBaseStore.applicationStore.pluginManager.getPureProtocolProcessorPlugins(),
+              ),
+              rawContract,
+            );
+
+            const dataContracts = contractResponse.dataContracts;
+            if (dataContracts?.[0]?.dataContract) {
+              const dataContract = dataContracts[0]?.dataContract;
+              const liteDataContract =
+                V1_transformDataContractToLiteDatacontract(dataContract);
+
+              const viewerState = new EntitlementsDataContractViewerState(
+                liteDataContract,
+                undefined,
+                marketplaceBaseStore.applicationStore,
+                marketplaceBaseStore.lakehouseContractServerClient,
+                new GraphManagerState(
+                  marketplaceBaseStore.applicationStore.pluginManager,
+                  marketplaceBaseStore.applicationStore.logService,
+                ),
+                marketplaceBaseStore.userSearchService,
+              );
+
+              setContractViewerState(viewerState);
+            }
+          } catch (error) {
+            assertErrorThrown(error);
+            marketplaceBaseStore.applicationStore.notificationService.notifyError(
+              `Error fetching contract: ${error.message}`,
+            );
+          }
+        };
+        // eslint-disable-next-line no-void
+        void fetchAndInitializeContract();
+      }, [contractId, auth.user?.access_token, marketplaceBaseStore]);
+
+      const handleRefresh = async (): Promise<void> => {
+        if (contractViewerState) {
+          contractViewerState.init(auth.user?.access_token);
+        }
+      };
+
+      const handleApprove = async () => {
+        const response =
+          await marketplaceBaseStore.lakehouseContractServerClient.approveTask(
+            taskId,
+            auth.user?.access_token,
+          );
+        const change = deserialize(
+          V1_TaskStatusChangeResponseModelSchema,
+          response,
+        );
+
+        if (change.errorMessage) {
+          throw new Error(`Unable to approve task: ${change.errorMessage}`);
+        }
+
+        marketplaceBaseStore.applicationStore.notificationService.notifySuccess(
+          'Task has been approved',
+        );
+
+        await handleRefresh();
+      };
+
+      const handleDeny = async () => {
+        const response =
+          await marketplaceBaseStore.lakehouseContractServerClient.denyTask(
+            taskId,
+            auth.user?.access_token,
+          );
+        const change = deserialize(
+          V1_TaskStatusChangeResponseModelSchema,
+          response,
+        );
+
+        if (change.errorMessage) {
+          throw new Error(`Unable to deny task: ${change.errorMessage}`);
+        }
+
+        marketplaceBaseStore.applicationStore.notificationService.notifySuccess(
+          'Task has been denied',
+        );
+
+        await handleRefresh();
+      };
+
+      const handleApproveClick = () => {
+        if (!isLoading) {
+          setIsLoading(true);
+          handleApprove()
+            .catch((error) => {
+              assertErrorThrown(error);
+              marketplaceBaseStore.applicationStore.notificationService.notifyError(
+                `Error approving task: ${error.message}`,
+              );
+            })
+            .finally(() => {
+              setIsLoading(false);
+            });
+        }
+      };
+
+      const handleDenyClick = () => {
+        if (!isLoading) {
+          setIsLoading(true);
+          handleDeny()
+            .catch((error) => {
+              assertErrorThrown(error);
+              marketplaceBaseStore.applicationStore.notificationService.notifyError(
+                `Error denying task: ${error.message}`,
+              );
+            })
+            .finally(() => {
+              setIsLoading(false);
+            });
+        }
+      };
+
+      return (
+        <LegendMarketplacePage className="marketplace-lakehouse-single-contract-viewer">
+          <CubesLoadingIndicator isLoading={isLoading}>
+            <CubesLoadingIndicatorIcon />
+          </CubesLoadingIndicator>
+          {contractViewerState && (
+            <div className="marketplace-lakehouse-single-contract-viewer__container">
+              {associatedTask !== undefined && (
+                <Box className="marketplace-lakehouse-single-contract-viewer__action-btns">
+                  <Tooltip
+                    className="marketplace-lakehouse-single-contract-viewer__tooltip__icon"
+                    title={
+                      !isTaskPending
+                        ? 'Task does not require review'
+                        : userCanApprove
+                          ? ''
+                          : 'You are not assigned to review this task'
+                    }
+                  >
+                    <Button
+                      variant="contained"
+                      color="success"
+                      onClick={handleApproveClick}
+                      disabled={!userCanApprove || isLoading}
+                    >
+                      Approve Task
+                    </Button>
+                  </Tooltip>
+                  <Tooltip
+                    className="marketplace-lakehouse-single-contract-viewer__tooltip__icon"
+                    title={
+                      !isTaskPending
+                        ? 'Task does not require review'
+                        : userCanApprove
+                          ? ''
+                          : 'You are not assigned to review this task'
+                    }
+                  >
+                    <Button
+                      variant="contained"
+                      color="error"
+                      onClick={handleDenyClick}
+                      disabled={!userCanApprove || isLoading}
+                    >
+                      Deny Task
+                    </Button>
+                  </Tooltip>
+                </Box>
+              )}
+              <EntitlementsDataContractContent
+                currentViewer={contractViewerState}
+                getContractTaskUrl={() =>
+                  marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
+                    generateContractPagePath(contractId, taskId),
+                  )
+                }
+                getDataProductUrl={(
+                  dataProductId: string,
+                  deploymentId: number,
+                ) =>
+                  marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
+                    generateLakehouseDataProductPath(
+                      dataProductId,
+                      deploymentId,
+                    ),
+                  )
+                }
+                initialSelectedUser={initialUser}
+                onRefresh={handleRefresh}
+                isReadOnly={true}
+              />
+            </div>
+          )}
+        </LegendMarketplacePage>
+      );
+    }),
+  );

package/src/stores/lakehouse/LegendMarketplaceProductViewerStore.ts

@@ -73,7 +73,7 @@ import {
   EXTERNAL_APPLICATION_NAVIGATION__generateDataSpaceQueryEditorUrl,
   EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl,
   generateLakehouseDataProductPath,
-  generateLakehouseTaskPath,
+  generateContractPagePath,
 } from '../../__lib__/LegendMarketplaceNavigation.js';
 import {
   DataSpaceViewerState,
@@ -418,9 +418,9 @@ export class LegendMarketplaceProductViewerStore {
         this.marketplaceBaseStore.lakehouseIngestServerClient,
         this.marketplaceBaseStore.applicationStore.pluginManager.getApplicationPlugins(),
         {
-          getContractTaskUrl: (taskId: string) =>
+          getContractTaskUrl: (contractId: string, taskId: string) =>
             this.marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(
-              generateLakehouseTaskPath(taskId),
+              generateContractPagePath(contractId, taskId),
             ),
           getDataProductUrl: (_dataProductId: string, _deploymentId: number) =>
             this.marketplaceBaseStore.applicationStore.navigationService.navigator.generateAddress(

package/tsconfig.json

@@ -122,6 +122,7 @@
     "./src/pages/Lakehouse/entitlements/EntitlementsClosedContractsDashboard.tsx",
     "./src/pages/Lakehouse/entitlements/EntitlementsPendingContractsDashboard.tsx",
     "./src/pages/Lakehouse/entitlements/EntitlementsPendingTasksDashboard.tsx",
+    "./src/pages/Lakehouse/entitlements/LakehouseDataContract.tsx",
     "./src/pages/Lakehouse/entitlements/LakehouseEntitlements.tsx",
     "./src/pages/Lakehouse/searchResults/LegendMarketplaceSearchResults.tsx",
     "./src/pages/Profile/LegendMarketplaceSubscriptions.tsx",