@orchestrator-ui/orchestrator-ui-components 1.3.1 → 1.5.0

package/src/rtk/endpoints/productsSummary.ts

@@ -0,0 +1,62 @@
+import { orchestratorApi } from '@/rtk';
+import {
+    BaseGraphQlResult,
+    GraphqlQueryVariables,
+    ProductDefinitionsResult,
+    ProductsSummary,
+} from '@/types';
+
+export const productsSummary = `
+    query MetadataProducts(
+        $first: Int!
+        $after: Int!
+        $sortBy: [GraphqlSort!]
+    ) {
+        products(first: $first, after: $after, sortBy: $sortBy) {
+            page {
+                name
+                subscriptions {
+                    pageInfo {
+                        totalItems
+                    }
+                }
+            }
+            pageInfo {
+                totalItems
+                startCursor
+                endCursor
+            }
+        }
+    }
+`;
+
+export type ProductsSummaryResponse = {
+    products: ProductsSummary[];
+} & BaseGraphQlResult;
+
+const productsSummaryApi = orchestratorApi.injectEndpoints({
+    endpoints: (builder) => ({
+        getProductsSummary: builder.query<
+            ProductsSummaryResponse,
+            GraphqlQueryVariables<ProductsSummary>
+        >({
+            query: (variables) => ({
+                document: productsSummary,
+                variables,
+            }),
+            transformResponse: (
+                response: ProductDefinitionsResult<ProductsSummary>,
+            ): ProductsSummaryResponse => {
+                const products = response.products.page || [];
+                const pageInfo = response.products.pageInfo || {};
+
+                return {
+                    products,
+                    pageInfo,
+                };
+            },
+        }),
+    }),
+});
+
+export const { useGetProductsSummaryQuery } = productsSummaryApi;

package/src/rtk/endpoints/relatedSubscriptions.ts

@@ -0,0 +1,99 @@
+import {
+    BaseGraphQlResult,
+    GraphqlFilter,
+    GraphqlQueryVariables,
+    RelatedSubscription,
+    RelatedSubscriptionsResult,
+    Subscription,
+} from '@/types';
+
+import { orchestratorApi } from '../api';
+
+export const RelatedSubscriptionsQuery = `
+query RelatedSubscriptions(
+    $subscriptionId: String!
+    $first: Int!
+    $after: Int!
+    $sortBy: [GraphqlSort!]
+    $terminatedSubscriptionFilter: [GraphqlFilter!]
+) {
+    subscriptions(
+        filterBy: { value: $subscriptionId, field: "subscriptionId" }
+    ) {
+        page {
+            subscriptionId
+            inUseBySubscriptions(
+                first: $first
+                after: $after
+                sortBy: $sortBy
+                filterBy: $terminatedSubscriptionFilter
+            ) {
+                page {
+                    subscriptionId
+                    customer {
+                        fullname
+                    }
+                    description
+                    insync
+                    startDate
+                    status
+                    product {
+                        tag
+                    }
+                }
+                pageInfo {
+                    endCursor
+                    hasNextPage
+                    hasPreviousPage
+                    startCursor
+                    totalItems
+                    sortFields
+                    filterFields
+                }
+            }
+        }
+    }
+}
+`;
+
+export type RelatedSubscriptionsResponse = {
+    relatedSubscriptions: RelatedSubscription[];
+} & BaseGraphQlResult;
+
+type RelatedSubscriptionVariables = GraphqlQueryVariables<RelatedSubscription> &
+    Pick<Subscription, 'subscriptionId'> & {
+        terminatedSubscriptionFilter?: GraphqlFilter<RelatedSubscription>;
+    };
+
+const relatedSubscriptionsApi = orchestratorApi.injectEndpoints({
+    endpoints: (build) => ({
+        getRelatedSubscriptions: build.query<
+            RelatedSubscriptionsResponse,
+            RelatedSubscriptionVariables
+        >({
+            query: (variables) => ({
+                document: RelatedSubscriptionsQuery,
+                variables,
+            }),
+            transformResponse: (
+                result: RelatedSubscriptionsResult,
+            ): RelatedSubscriptionsResponse => {
+                const relatedSubscriptionResultForSubscription =
+                    result.subscriptions.page[0] || [];
+                const relatedSubscriptions =
+                    relatedSubscriptionResultForSubscription
+                        .inUseBySubscriptions.page || [];
+                const pageInfo =
+                    relatedSubscriptionResultForSubscription
+                        .inUseBySubscriptions.pageInfo || {};
+
+                return {
+                    relatedSubscriptions,
+                    pageInfo,
+                };
+            },
+        }),
+    }),
+});
+
+export const { useGetRelatedSubscriptionsQuery } = relatedSubscriptionsApi;

package/src/rtk/endpoints/settings.ts

@@ -46,6 +46,15 @@ const statusApi = orchestratorApi.injectEndpoints({
                 baseQueryType: BaseQueryTypes.fetch,
             },
         }),
+        resetTextSearchIndex: build.mutation<void, null>({
+            query: () => ({
+                url: `/settings/search-index/reset`,
+                method: 'POST',
+            }),
+            extraOptions: {
+                baseQueryType: BaseQueryTypes.fetch,
+            },
+        }),
         setEngineStatus: build.mutation<EngineStatusReturnValue, boolean>({
             query: (globalStatus) => ({
                 url: `/settings/status`,
@@ -68,5 +77,6 @@ const statusApi = orchestratorApi.injectEndpoints({
 export const {
     useGetEngineStatusQuery,
     useClearCacheMutation,
+    useResetTextSearchIndexMutation,
     useSetEngineStatusMutation,
 } = statusApi;

package/src/rtk/endpoints/startOptions.ts

@@ -0,0 +1,99 @@
+import {
+    ProductDefinition,
+    StartOptionsResult,
+    WorkflowDefinition,
+    WorkflowTarget,
+} from '@/types';
+
+import { orchestratorApi } from '../api';
+
+const workflowOptionsQuery = `
+    query StartOptions {
+        workflows(first: 1000000, after: 0, filterBy: [{ field: "target", value: "${WorkflowTarget.CREATE}"}]) {
+            page {
+                name
+                products {
+                    productId
+                    name
+                }
+            }
+        }
+    }
+`;
+
+const taskOptionsQuery = `
+    query StartOptions {
+        workflows(first: 1000000, after: 0, filterBy: [{ field: "target", value: "${WorkflowTarget.SYSTEM}"}]) {
+            page {
+                name
+                description
+            }
+        }
+    }
+`;
+
+type WorkflowOption = {
+    workflowName: WorkflowDefinition['name'];
+    productName: ProductDefinition['name'];
+    productId: ProductDefinition['productId'];
+};
+
+type WorkflowOptionsResult = StartOptionsResult<{
+    name: WorkflowDefinition['name'];
+    products: {
+        name: ProductDefinition['name'];
+        productId: ProductDefinition['productId'];
+    }[];
+}>;
+
+export type StartOptionsResponse<StartOption> = {
+    startOptions: StartOption[];
+};
+
+type TaskOption = Pick<WorkflowDefinition, 'name' | 'description'>;
+type TaskOptionsResult = StartOptionsResult<TaskOption>;
+
+const startButtonOptionsApi = orchestratorApi.injectEndpoints({
+    endpoints: (build) => ({
+        getWorkflowOptions: build.query<
+            StartOptionsResponse<WorkflowOption>,
+            void
+        >({
+            query: () => ({
+                document: workflowOptionsQuery,
+            }),
+            transformResponse: (response: WorkflowOptionsResult) => {
+                const startOptions: WorkflowOption[] = [];
+                const workflows = response.workflows?.page || [];
+                workflows.forEach((workflow) => {
+                    const workflowName = workflow.name;
+                    workflow.products.forEach((product) => {
+                        startOptions.push({
+                            workflowName,
+                            productName: product.name,
+                            productId: product.productId,
+                        });
+                    });
+                });
+
+                return { startOptions };
+            },
+        }),
+        getTaskOptions: build.query<StartOptionsResponse<TaskOption>, void>({
+            query: () => ({
+                document: taskOptionsQuery,
+            }),
+            transformResponse: (response: TaskOptionsResult) => {
+                return {
+                    startOptions: response.workflows.page.map((option) => ({
+                        name: option.name,
+                        description: option.description,
+                    })),
+                };
+            },
+        }),
+    }),
+});
+
+export const { useGetWorkflowOptionsQuery, useGetTaskOptionsQuery } =
+    startButtonOptionsApi;

package/src/{graphqlQueries/subscriptionDetailQuery.ts → rtk/endpoints/subscriptionDetail.ts}

@@ -1,14 +1,11 @@
-import { parse } from 'graphql';
-import { gql } from 'graphql-request';
-
-import { TypedDocumentNode } from '@graphql-typed-document-node/core';
-
-import { SubscriptionDetailResult } from '../types';
-
-export const GET_SUBSCRIPTION_DETAIL_GRAPHQL_QUERY: TypedDocumentNode<
+import { CacheTags, orchestratorApi } from '@/rtk';
+import {
+    BaseGraphQlResult,
+    SubscriptionDetail,
     SubscriptionDetailResult,
-    { subscriptionId: string }
-> = parse(gql`
+} from '@/types';
+
+export const subscriptionDetailQuery = `
     query SubscriptionDetail($subscriptionId: String!) {
         subscriptions(
             filterBy: { value: $subscriptionId, field: "subscriptionId" }
@@ -60,4 +57,41 @@ export const GET_SUBSCRIPTION_DETAIL_GRAPHQL_QUERY: TypedDocumentNode<
             }
         }
     }
-`);
+`;
+
+export type SubscriptionDetailResponse = {
+    subscription: SubscriptionDetail;
+} & BaseGraphQlResult;
+
+const subscriptionDetailApi = orchestratorApi.injectEndpoints({
+    endpoints: (builder) => ({
+        getSubscriptionDetail: builder.query<
+            SubscriptionDetailResponse,
+            { subscriptionId: string }
+        >({
+            query: (variables) => ({
+                document: subscriptionDetailQuery,
+                variables,
+            }),
+            transformResponse: (
+                response: SubscriptionDetailResult,
+            ): SubscriptionDetailResponse => {
+                const subscription = response.subscriptions.page[0] || [];
+                const pageInfo = response.subscriptions.pageInfo || {};
+
+                return {
+                    subscription,
+                    pageInfo,
+                };
+            },
+            providesTags: (result, error, arg) => [
+                {
+                    type: CacheTags.subscription,
+                    id: arg.subscriptionId,
+                },
+            ],
+        }),
+    }),
+});
+
+export const { useGetSubscriptionDetailQuery } = subscriptionDetailApi;

package/src/rtk/endpoints/subscriptionList.ts

@@ -0,0 +1,86 @@
+import { SubscriptionListItem } from '@/components/WfoSubscriptionsList';
+import { CacheTags, orchestratorApi } from '@/rtk';
+import {
+    BaseGraphQlResult,
+    GraphqlQueryVariables,
+    Subscription,
+    SubscriptionsResult,
+} from '@/types';
+
+export const subscriptionListQuery = `query SubscriptionsList(
+        $first: Int!
+        $after: Int!
+        $sortBy: [GraphqlSort!]
+        $filterBy: [GraphqlFilter!]
+        $query: String
+    ) {
+        subscriptions(
+            first: $first
+            after: $after
+            sortBy: $sortBy
+            filterBy: $filterBy
+            query: $query
+        ) {
+            page {
+                note
+                startDate
+                endDate
+                description
+                insync
+                status
+                subscriptionId
+                product {
+                    name
+                    tag
+                    productType
+                }
+                customer {
+                    fullname
+                    shortcode
+                }
+            }
+            pageInfo {
+                totalItems
+                startCursor
+                hasPreviousPage
+                hasNextPage
+                endCursor
+                sortFields
+                filterFields
+            }
+        }
+    }
+`;
+
+export type SubscriptionListResponse = {
+    subscriptions: Subscription[];
+} & BaseGraphQlResult;
+
+const subscriptionListApi = orchestratorApi.injectEndpoints({
+    endpoints: (builder) => ({
+        getSubscriptionList: builder.query<
+            SubscriptionListResponse,
+            GraphqlQueryVariables<SubscriptionListItem>
+        >({
+            query: (variables) => ({
+                document: subscriptionListQuery,
+                variables,
+            }),
+            transformResponse: (
+                response: SubscriptionsResult,
+            ): SubscriptionListResponse => {
+                const subscriptions = response.subscriptions.page || [];
+                const pageInfo = response.subscriptions.pageInfo || {};
+
+                return {
+                    subscriptions,
+                    pageInfo,
+                };
+            },
+            providesTags: [CacheTags.subscriptionList],
+        }),
+    }),
+});
+
+export const { useGetSubscriptionListQuery, useLazyGetSubscriptionListQuery } =
+    subscriptionListApi;

package/src/rtk/endpoints/subscriptionListSummary.ts

@@ -0,0 +1,70 @@
+import { CacheTags, orchestratorApi } from '@/rtk';
+import {
+    BaseGraphQlResult,
+    GraphqlQueryVariables,
+    Subscription,
+    SubscriptionSummary,
+    SubscriptionsResult,
+} from '@/types';
+
+export const subscriptionListSummaryQuery = `
+    query SubscriptionsList(
+        $first: Int!
+        $after: Int!
+        $sortBy: [GraphqlSort!]
+        $filterBy: [GraphqlFilter!]
+        $query: String
+    ) {
+        subscriptions(
+            first: $first
+            after: $after
+            sortBy: $sortBy
+            filterBy: $filterBy
+            query: $query
+        ) {
+            page {
+                startDate
+                description
+                subscriptionId
+            }
+            pageInfo {
+                totalItems
+                startCursor
+                endCursor
+            }
+        }
+    }
+`;
+
+export type SubscriptionListSummaryResponse = {
+    subscriptions: SubscriptionSummary[];
+} & BaseGraphQlResult;
+
+const subscriptionListSummaryApi = orchestratorApi.injectEndpoints({
+    endpoints: (builder) => ({
+        getSubscriptionSummaryList: builder.query<
+            SubscriptionListSummaryResponse,
+            GraphqlQueryVariables<Subscription>
+        >({
+            query: (variables) => ({
+                document: subscriptionListSummaryQuery,
+                variables,
+            }),
+            transformResponse: (
+                response: SubscriptionsResult<SubscriptionSummary>,
+            ): SubscriptionListSummaryResponse => {
+                const subscriptions = response.subscriptions.page || [];
+                const pageInfo = response.subscriptions.pageInfo || {};
+
+                return {
+                    subscriptions,
+                    pageInfo,
+                };
+            },
+            providesTags: [CacheTags.subscriptionList],
+        }),
+    }),
+});
+
+export const { useGetSubscriptionSummaryListQuery } =
+    subscriptionListSummaryApi;

package/src/rtk/endpoints/subscriptionsDropdownOptions.ts

@@ -0,0 +1,72 @@
+import { NUMBER_OF_ITEMS_REPRESENTING_ALL_ITEMS } from '@/configuration';
+import { orchestratorApi } from '@/rtk';
+import {
+    GraphqlQueryVariables,
+    SubscriptionDropdownOption,
+    SubscriptionDropdownOptionsResult,
+} from '@/types';
+
+export const subscriptionsDropdownOptionsQuery = `
+    query SubscriptionDropdownOptions(
+        $filterBy: [GraphqlFilter!]
+        $first: Int!
+    ) {
+        subscriptions(filterBy: $filterBy, first: $first, after: 0) {
+            page {
+                description
+                subscriptionId
+                product {
+                    tag
+                    productId
+                }
+                customer {
+                    fullname
+                    customerId
+                }
+                productBlockInstances {
+                    id
+                    ownerSubscriptionId
+                    parent
+                    productBlockInstanceValues
+                    subscriptionInstanceId
+                    inUseByRelations
+                }
+                fixedInputs
+            }
+        }
+    }
+`;
+
+export type SubscriptionDropdownOptionsResponse = {
+    subscriptionDropdownOptions: SubscriptionDropdownOption[];
+};
+
+const subscriptionsDropdownOptionsApi = orchestratorApi.injectEndpoints({
+    endpoints: (builder) => ({
+        getSubscriptionsDropdownOptions: builder.query<
+            SubscriptionDropdownOptionsResponse,
+            GraphqlQueryVariables<SubscriptionDropdownOption>
+        >({
+            query: (variables) => ({
+                document: subscriptionsDropdownOptionsQuery,
+                variables: {
+                    ...variables,
+                    first: NUMBER_OF_ITEMS_REPRESENTING_ALL_ITEMS,
+                },
+            }),
+            transformResponse: (
+                response: SubscriptionDropdownOptionsResult,
+            ): SubscriptionDropdownOptionsResponse => {
+                const subscriptionDropdownOptions =
+                    response.subscriptions.page || [];
+
+                return {
+                    subscriptionDropdownOptions,
+                };
+            },
+        }),
+    }),
+});
+
+export const { useGetSubscriptionsDropdownOptionsQuery } =
+    subscriptionsDropdownOptionsApi;

package/src/types/types.ts

@@ -109,6 +109,9 @@ export interface ProductDefinition {
     fixedInputs: Pick<FixedInputDefinition, 'name' | 'value'>[];
 }
 
+export type ProductsSummary = Pick<ProductDefinition, 'name'> &
+    SubscriptionsResult<never>;
+
 export enum WorkflowTarget {
     CREATE = 'create',
     MODIFY = 'modify',
@@ -333,6 +336,10 @@ export interface WorkflowDefinitionsResult<T = WorkflowDefinition> {
     workflows: GraphQlResultPage<T>;
 }
 
+export interface StartOptionsResult<T> {
+    workflows: GraphQlSinglePage<T>;
+}
+
 export interface RelatedSubscriptionsResult {
     subscriptions: GraphQlSinglePage<
         Pick<Subscription, 'subscriptionId'> & {
@@ -341,6 +348,14 @@ export interface RelatedSubscriptionsResult {
     >;
 }
 
+export type StartComboBoxOption = {
+    data: {
+        workflowName: string;
+        productId?: string;
+    };
+    label: string;
+};
+
 interface GraphQlResultPage<T> {
     page: T[];
     pageInfo: GraphQLPageInfo;
@@ -382,6 +397,11 @@ export type Subscription = {
     customer: Pick<Customer, 'fullname' | 'shortcode'>;
 };
 
+export type SubscriptionSummary = Pick<
+    Subscription,
+    'subscriptionId' | 'description' | 'startDate'
+>;
+
 export type SubscriptionDropdownOption = {
     description: Subscription['description'];
     subscriptionId: Subscription['subscriptionId'];

package/src/utils/index.ts

@@ -1,3 +1,4 @@
+export * from './csvDownload';
 export * from './date';
 export * from './environmentVariables';
 export * from './getStatusBadgeColor';

package/src/components/WfoPageTemplate/WfoSidebar/WfoStartCreateWorkflowButtonComboBox.tsx

@@ -1,61 +0,0 @@
-import React from 'react';
-
-import { useTranslations } from 'next-intl';
-import { useRouter } from 'next/router';
-
-import { GET_WORKFLOWS_FOR_DROPDOWN_LIST_GRAPHQL_QUERY } from '@/graphqlQueries/workflows/workflowsQueryForDropdownList';
-import { useCheckEngineStatus, useQueryWithGraphql } from '@/hooks';
-
-import {
-    WfoButtonComboBox,
-    WorkflowComboBoxOption,
-} from '../../WfoButtonComboBox/WfoButtonComboBox';
-import { PATH_START_NEW_WORKFLOW } from '../paths';
-
-export const WfoStartCreateWorkflowButtonComboBox = () => {
-    const router = useRouter();
-    const t = useTranslations('common');
-    const { isEngineRunningNow } = useCheckEngineStatus();
-
-    const { data } = useQueryWithGraphql(
-        GET_WORKFLOWS_FOR_DROPDOWN_LIST_GRAPHQL_QUERY,
-        {
-            filterBy: [{ field: 'target', value: 'CREATE' }],
-        },
-        'createWorkflows',
-    );
-
-    const productList: WorkflowComboBoxOption[] =
-        data?.workflows.page
-            .flatMap(({ name: workflowName, products }) =>
-                products.map(({ productId, name: productName }) => ({
-                    label: productName,
-                    data: {
-                        workflowName,
-                        productId,
-                    },
-                })),
-            )
-            .sort((a, b) => a.label.localeCompare(b.label)) ?? [];
-
-    const handleOptionChange = async (
-        selectedProduct: WorkflowComboBoxOption,
-    ) => {
-        if (await isEngineRunningNow()) {
-            const { workflowName, productId } = selectedProduct.data;
-            router.push({
-                pathname: `${PATH_START_NEW_WORKFLOW}/${workflowName}`,
-                query: { productId },
-            });
-        }
-    };
-
-    return (
-        <WfoButtonComboBox
-            buttonText={t('newSubscription')}
-            options={productList}
-            onOptionChange={handleOptionChange}
-            isProcess
-        />
-    );
-};