/**
* Copyright (c) 2025-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 React, {
useCallback,
useEffect,
useMemo,
useRef,
useState,
} from 'react';
import { observer } from 'mobx-react-lite';
import {
Box,
Typography,
Tabs,
Tab,
Chip,
CircularProgress,
Button,
ButtonGroup,
Accordion,
AccordionSummary,
AccordionDetails,
Stack,
Tooltip,
TextField,
InputAdornment,
IconButton,
Select,
MenuItem,
type SelectChangeEvent,
} from '@mui/material';
import { flowResult } from 'mobx';
import {
ShoppingCartIcon,
ChevronDownIcon,
TimesCircleIcon,
OpenNewTabIcon,
SearchIcon,
CopyIcon,
CloseIcon,
TuneIcon,
} from '@finos/legend-art';
import { LegendMarketplacePage } from '../LegendMarketplacePage.js';
import { useLegendMarketplaceBaseStore } from '../../application/providers/LegendMarketplaceFrameworkProvider.js';
import {
type TerminalProductOrder,
OrderStatus,
OrderSearchStatus,
} from '@finos/legend-server-marketplace';
import { assertErrorThrown, isNullable } from '@finos/legend-shared';
import {
useLegendMarketplaceOrdersStore,
withLegendMarketplaceOrdersStore,
} from '../../application/providers/LegendMarketplaceYourOrdersStoreProvider.js';
import { ProgressTracker } from '../../components/orders/ProgressTracker.js';
import { CancelOrderDialog } from '../../components/orders/CancelOrderDialog.js';
import { AdvancedOrderSearchPopover } from '../../components/orders/AdvancedOrderSearchPopover.js';
import {
formatOrderDate,
canCancelOrder,
formatTimestamp,
getCurrentStageTrackingUrl,
getClosureInfo,
getOrderSearchStatusLabel,
isLastDaysSearchDefaulted,
ORDER_SEARCH_PAGE_SIZE_OPTIONS,
} from '../../stores/orders/OrderHelpers.js';
import { LegendMarketplaceTelemetryHelper } from '../../__lib__/LegendMarketplaceTelemetryHelper.js';
import {
OrderTab,
type OrderSearchFormValues,
} from '../../stores/orders/OrderStore.js';
const getEmptyOrdersTitle = (
hasSearchTerm: boolean,
selectedTab: OrderTab,
isAdvancedSearchActive: boolean,
): string => {
if (isAdvancedSearchActive) {
return 'No orders match your search filters';
}
if (hasSearchTerm) {
return 'No orders match your search';
}
return `No ${selectedTab === OrderTab.OPEN ? 'active' : 'completed'} orders found`;
};
const getEmptyOrdersDescription = (
hasSearchTerm: boolean,
selectedTab: OrderTab,
isAdvancedSearchActive: boolean,
): string => {
if (isAdvancedSearchActive) {
return 'Try adjusting the filters in Advanced Search, or clear the search to see your orders.';
}
if (hasSearchTerm) {
return 'Try adjusting your search terms and try again.';
}
return selectedTab === OrderTab.OPEN
? "You don't have any orders in progress. Start shopping to place your first order!"
: "You don't have any completed orders yet. Your completed orders will appear here.";
};
const filterOrdersBySearchTerm = (
orders: TerminalProductOrder[],
searchTerm: string,
): TerminalProductOrder[] => {
const query = searchTerm.trim().toLowerCase();
if (!query) {
return orders;
}
return orders.filter(
(order) =>
order.order_id.toLowerCase().includes(query) ||
(order.ordered_by_name || order.ordered_by)
.toLowerCase()
.includes(query) ||
(order.ordered_for_name || order.ordered_for)
.toLowerCase()
.includes(query) ||
order.service_pricing_items.some((item) =>
item.entity_name.toLowerCase().includes(query),
),
);
};
const OrderAccordion: React.FC<{
order: TerminalProductOrder;
isOpenOrder: boolean;
isExpanded: boolean;
onToggleExpanded: (orderId: string) => void;
}> = observer(({ order, isOpenOrder, isExpanded, onToggleExpanded }) => {
const [cancelDialogOpen, setCancelDialogOpen] = useState(false);
const ordersStore = useLegendMarketplaceOrdersStore();
const baseStore = useLegendMarketplaceBaseStore();
const isCancellable = canCancelOrder(order);
const trackingUrl = getCurrentStageTrackingUrl(order);
const closureInfo = getClosureInfo(order);
// Advanced search results can include orders belonging to other users
// (searched via Ordered By/For), so cancellation must be blocked in that
// mode to prevent accidentally cancelling someone else's order.
const isCancelDisabled = !isCancellable || ordersStore.isAdvancedSearchActive;
let cancelDisabledReason = '';
if (ordersStore.isAdvancedSearchActive) {
cancelDisabledReason = 'You are not authorised to perform this action';
} else if (!isCancellable) {
cancelDisabledReason =
'Order cancellation is not available once the order has reached the fulfillment stage';
}
const handleCancelClick = (): void => {
setCancelDialogOpen(true);
};
const handleCopyOrderId = (e: React.MouseEvent): void => {
e.stopPropagation();
baseStore.applicationStore.clipboardService
.copyTextToClipboard(order.order_id)
.then(() =>
baseStore.applicationStore.notificationService.notifySuccess(
'Order ID copied to clipboard',
undefined,
2500,
),
)
.catch(baseStore.applicationStore.alertUnhandledError);
};
const formatCurrency = (
amount: number | string | null | undefined,
): string => {
let numAmount: number;
if (isNullable(amount) || amount === 'null') {
numAmount = 0;
} else if (typeof amount === 'string') {
numAmount = Number.parseFloat(amount);
} else {
numAmount = amount;
}
return numAmount.toLocaleString('en-US', {
style: 'currency',
currency: 'USD',
});
};
return (
<>
onToggleExpanded(order.order_id)}
sx={{ '&:before': { display: 'none' }, mb: 2 }}
>
}
aria-controls={`${order.order_id}-content`}
aria-label={`Order ${order.order_id} summary`}
id={`${order.order_id}-header`}
className="legend-marketplace-order-accordion__summary"
>
Order #
{order.order_id}
Ordered By
{order.ordered_by_name || order.ordered_by}
Ordered For
{order.ordered_for_name || order.ordered_for}
Date Ordered
{formatOrderDate(order.created_at)}
Total Cost (monthly)
{formatCurrency(order.order_cost)}
Order Type
{order.order_type}
{!isOpenOrder && (
Status
{order.status || 'N/A'}
)}
{isOpenOrder && (
}
disabled={!trackingUrl}
onClick={(e) => {
e.stopPropagation();
if (trackingUrl) {
LegendMarketplaceTelemetryHelper.logEvent_ClickOrderEtaskLink(
baseStore.applicationStore.telemetryService,
String(order.order_id),
);
baseStore.applicationStore.navigationService.navigator.visitAddress(
trackingUrl,
);
}
}}
className="legend-marketplace-order-accordion__track-button"
>
Track Order
}
disabled={isCancelDisabled}
onClick={(e) => {
e.stopPropagation();
handleCancelClick();
}}
className="legend-marketplace-order-accordion__cancel-button"
>
Cancel Order
)}
{!isOpenOrder && closureInfo && (
Closure Information
Closed At Stage:
{closureInfo.stageLabel}
Closure Reason:
{closureInfo.reason ?? 'N/A'}
Closed By:
{closureInfo.actionedBy ?? 'N/A'}
Closure Date:
{closureInfo.actionedTimestamp
? formatTimestamp(closureInfo.actionedTimestamp)
: 'N/A'}
{closureInfo.comment && (
Comment:
{closureInfo.comment}
)}
)}
{order.service_pricing_items.map((item, index) => (
{order.vendor_name}
{item.entity_name}
{index === order.service_pricing_items.length - 1 &&
order.business_justification && (
Business Justification: {order.business_justification}
)}
))}
{order.workflow_details && }
setCancelDialogOpen(false)}
order={order}
orderStore={ordersStore}
/>
>
);
});
export const LegendMarketplaceYourOrders: React.FC =
withLegendMarketplaceOrdersStore(
observer(() => {
const baseStore = useLegendMarketplaceBaseStore();
const ordersStore = useLegendMarketplaceOrdersStore();
const executeFlowSafely = useCallback(
(flowFn: () => Generator, void, unknown>) => {
flowResult(flowFn()).catch((error) => {
assertErrorThrown(error);
baseStore.applicationStore.alertUnhandledError(error);
});
},
[baseStore.applicationStore],
);
const handleTabChange = useCallback(
(_event: React.SyntheticEvent, newValue: OrderTab) => {
ordersStore.setSelectedTab(newValue);
if (
newValue === OrderTab.OPEN &&
ordersStore.fetchOpenOrdersState.isInInitialState
) {
executeFlowSafely(() => ordersStore.fetchOpenOrders());
} else if (
newValue === OrderTab.CLOSED &&
ordersStore.fetchClosedOrdersState.isInInitialState
) {
executeFlowSafely(() => ordersStore.fetchClosedOrders());
}
},
[ordersStore, executeFlowSafely],
);
useEffect(() => {
if (ordersStore.openOrders.length === 0) {
executeFlowSafely(() => ordersStore.fetchOpenOrders());
}
}, [ordersStore, executeFlowSafely]);
useEffect(() => {
LegendMarketplaceTelemetryHelper.logEvent_ViewYourOrdersPage(
baseStore.applicationStore.telemetryService,
);
}, [baseStore.applicationStore.telemetryService]);
const [searchTerm, setSearchTerm] = useState('');
// Orders whose accordion is collapsed; absence from the set means
// expanded (so orders default to expanded without needing a sync effect).
const [collapsedOrderIds, setCollapsedOrderIds] = useState>(
new Set(),
);
const [advancedSearchAnchorEl, setAdvancedSearchAnchorEl] =
useState(null);
// Bumped whenever the advanced search is cleared from the search bar's
// clear (x) button so the popover (which owns its own uncontrolled
// orderedBy/orderedFor/status/lastDays state) remounts with fresh,
// blank fields instead of retaining stale values from the prior search.
const [advancedSearchResetKey, setAdvancedSearchResetKey] = useState(0);
const isAdvancedSearchActive = ordersStore.isAdvancedSearchActive;
const appliedSearchFilters = ordersStore.appliedSearchFilters;
const handleAdvancedSearchOpen = useCallback(
(event: React.MouseEvent) => {
setAdvancedSearchAnchorEl(event.currentTarget);
},
[],
);
const handleAdvancedSearchClose = useCallback(() => {
setAdvancedSearchAnchorEl(null);
}, []);
const handleAdvancedSearch = useCallback(
(filters: OrderSearchFormValues) => {
LegendMarketplaceTelemetryHelper.logEvent_AdvancedSearchOrders(
baseStore.applicationStore.telemetryService,
Boolean(filters.orderedBy?.id.trim()),
Boolean(filters.orderedFor?.id.trim()),
filters.status,
isLastDaysSearchDefaulted(filters.lastDays),
);
executeFlowSafely(() => ordersStore.searchOrders(filters));
setSearchTerm('');
},
[
baseStore.applicationStore.telemetryService,
executeFlowSafely,
ordersStore,
],
);
// The popover stays open (showing its own loading state) while a search
// is in flight so the user gets feedback that results are being
// processed; it is only dismissed once the search settles.
const wasSearchingRef = useRef(false);
useEffect(() => {
const isSearchInProgress = ordersStore.searchOrdersState.isInProgress;
if (
wasSearchingRef.current &&
!isSearchInProgress &&
advancedSearchAnchorEl
) {
setAdvancedSearchAnchorEl(null);
}
wasSearchingRef.current = isSearchInProgress;
}, [ordersStore.searchOrdersState.isInProgress, advancedSearchAnchorEl]);
const handleClearAdvancedSearch = useCallback(() => {
LegendMarketplaceTelemetryHelper.logEvent_ClearAdvancedOrderSearch(
baseStore.applicationStore.telemetryService,
);
ordersStore.clearSearch();
setSearchTerm('');
setAdvancedSearchResetKey((key) => key + 1);
if (ordersStore.currentFetchState.isInInitialState) {
if (ordersStore.selectedTab === OrderTab.OPEN) {
executeFlowSafely(() => ordersStore.fetchOpenOrders());
} else {
executeFlowSafely(() => ordersStore.fetchClosedOrders());
}
}
}, [
baseStore.applicationStore.telemetryService,
executeFlowSafely,
ordersStore,
]);
const currentOrders = ordersStore.currentOrders;
const isLoading = ordersStore.currentFetchState.isInProgress;
const filteredOrders = useMemo(
() => filterOrdersBySearchTerm(currentOrders, searchTerm),
[currentOrders, searchTerm],
);
const handleToggleOrder = useCallback((orderId: string) => {
setCollapsedOrderIds((prev) => {
const next = new Set(prev);
if (next.has(orderId)) {
next.delete(orderId);
} else {
next.add(orderId);
}
return next;
});
}, []);
const handleCollapseAllOrders = useCallback(() => {
LegendMarketplaceTelemetryHelper.logEvent_ToggleAllOrders(
baseStore.applicationStore.telemetryService,
false,
);
setCollapsedOrderIds(
new Set(filteredOrders.map((order) => order.order_id)),
);
}, [baseStore.applicationStore.telemetryService, filteredOrders]);
const handleExpandAllOrders = useCallback(() => {
LegendMarketplaceTelemetryHelper.logEvent_ToggleAllOrders(
baseStore.applicationStore.telemetryService,
true,
);
setCollapsedOrderIds(new Set());
}, [baseStore.applicationStore.telemetryService]);
const handleSearchPageSizeChange = useCallback(
(event: SelectChangeEvent) => {
const pageSize = Number(event.target.value);
LegendMarketplaceTelemetryHelper.logEvent_ChangeAdvancedOrderSearchPageSize(
baseStore.applicationStore.telemetryService,
pageSize,
);
executeFlowSafely(() => ordersStore.setSearchPageSize(pageSize));
},
[
baseStore.applicationStore.telemetryService,
executeFlowSafely,
ordersStore,
],
);
const handlePaginateSearch = useCallback(
(direction: 'previous' | 'next') => {
const delta =
direction === 'previous'
? -ordersStore.searchPageSize
: ordersStore.searchPageSize;
const offset = Math.max(0, ordersStore.searchOffset + delta);
LegendMarketplaceTelemetryHelper.logEvent_PaginateAdvancedOrderSearch(
baseStore.applicationStore.telemetryService,
offset,
ordersStore.searchPageSize,
);
executeFlowSafely(() => ordersStore.goToSearchOffset(offset));
},
[
baseStore.applicationStore.telemetryService,
executeFlowSafely,
ordersStore,
],
);
let ordersSectionContent: React.ReactNode;
if (isLoading) {
ordersSectionContent = (
Loading your orders...
);
} else if (filteredOrders.length === 0) {
ordersSectionContent = (
{getEmptyOrdersTitle(
Boolean(searchTerm.trim()),
ordersStore.selectedTab,
isAdvancedSearchActive,
)}
{getEmptyOrdersDescription(
Boolean(searchTerm.trim()),
ordersStore.selectedTab,
isAdvancedSearchActive,
)}
);
} else {
ordersSectionContent = (
<>
{filteredOrders.length > 1 && (
)}
{filteredOrders.map((order) => {
const isOpenOrder =
order.workflow_details?.workflow_status ===
OrderStatus.IN_PROGRESS ||
order.workflow_details?.workflow_status === OrderStatus.OPEN;
return (
);
})}
{isAdvancedSearchActive && appliedSearchFilters && (
Orders per page:
Page {ordersStore.searchCurrentPage} of{' '}
{ordersStore.hasNextSearchPage
? `${ordersStore.searchCurrentPage + 1}+`
: ordersStore.searchCurrentPage}
)}
>
);
}
return (
Your Orders
{isAdvancedSearchActive && appliedSearchFilters ? (
{appliedSearchFilters.orderId && (
)}
{appliedSearchFilters.orderedByLabel && (
)}
{appliedSearchFilters.orderedForLabel && (
)}
{appliedSearchFilters.status !== OrderSearchStatus.ALL && (
)}
{!appliedSearchFilters.isLastDaysDefaulted && (
)}
) : (
setSearchTerm(e.target.value)}
className="legend-marketplace-your-orders__search-field"
slotProps={{
input: {
endAdornment: (
{searchTerm && (
setSearchTerm('')}
>
)}
),
},
}}
/>
)}
{isAdvancedSearchActive && appliedSearchFilters && (
setSearchTerm(e.target.value)}
className="legend-marketplace-your-orders__search-field"
slotProps={{
input: {
startAdornment: (
),
endAdornment: searchTerm && (
setSearchTerm('')}
>
),
},
}}
/>
{appliedSearchFilters.isLastDaysDefaulted &&
!appliedSearchFilters.orderId && (
We are showing orders for the last{' '}
{appliedSearchFilters.lastDays} days
)}
)}
{!isAdvancedSearchActive && (
)}
{ordersSectionContent}
);
}),
);