@zeniai/client-epic-state 5.0.2 → 5.0.3-betaND1

package/lib/view/aiAccountantView/aiAccountantViewPayload.d.ts

@@ -0,0 +1,31 @@
+import { ZeniAPIResponse } from '../../responsePayload';
+export { AiAccountantCustomerPayload, AiAccountantEnrollmentPayload, AiAccountantJobPayload, toAiAccountantCustomer, toAiAccountantEnrollment, toAiAccountantJob, } from '../../entity/aiAccountantCustomer/aiAccountantCustomerPayload';
+import type { AiAccountantCustomerPayload, AiAccountantJobPayload } from '../../entity/aiAccountantCustomer/aiAccountantCustomerPayload';
+import { UserPayload } from '../../entity/user/userPayload';
+export interface AiAccountantCustomersResponseData {
+    customers: AiAccountantCustomerPayload[];
+    users: UserPayload[];
+}
+export interface AiAccountantJobsResponseData {
+    jobs: AiAccountantJobPayload[];
+    page_size: number;
+    users: UserPayload[];
+    next_page_token?: string | null;
+}
+export interface AiAccountantTriggerJobResponseData {
+    job_ids: string[];
+    queued_count: number;
+    skipped?: Array<{
+        reason: string;
+        tenant_id: string;
+    }>;
+}
+export interface AiAccountantCancelOnboardingResponseData {
+    cancelled_jobs: string[];
+    ok: boolean;
+    workflow_cancelled: boolean;
+}
+export type AiAccountantCustomersResponse = ZeniAPIResponse<AiAccountantCustomersResponseData>;
+export type AiAccountantJobsResponse = ZeniAPIResponse<AiAccountantJobsResponseData>;
+export type AiAccountantTriggerJobResponse = ZeniAPIResponse<AiAccountantTriggerJobResponseData>;
+export type AiAccountantCancelOnboardingResponse = ZeniAPIResponse<AiAccountantCancelOnboardingResponseData>;

package/lib/view/aiAccountantView/aiAccountantViewPayload.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAiAccountantJob = exports.toAiAccountantEnrollment = exports.toAiAccountantCustomer = void 0;
+// Re-export entity payload types and mapping functions.
+var aiAccountantCustomerPayload_1 = require("../../entity/aiAccountantCustomer/aiAccountantCustomerPayload");
+Object.defineProperty(exports, "toAiAccountantCustomer", { enumerable: true, get: function () { return aiAccountantCustomerPayload_1.toAiAccountantCustomer; } });
+Object.defineProperty(exports, "toAiAccountantEnrollment", { enumerable: true, get: function () { return aiAccountantCustomerPayload_1.toAiAccountantEnrollment; } });
+Object.defineProperty(exports, "toAiAccountantJob", { enumerable: true, get: function () { return aiAccountantCustomerPayload_1.toAiAccountantJob; } });

package/lib/view/aiAccountantView/aiAccountantViewReducer.d.ts

@@ -0,0 +1,29 @@
+import { AiAccountantCustomerPayload } from '../../entity/aiAccountantCustomer/aiAccountantCustomerPayload';
+import { ID } from '../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { AiAccountantUIState, AiAccountantViewState } from './aiAccountantViewState';
+export declare const initialAiAccountantViewState: AiAccountantViewState;
+export declare const cancelAiAccountantOnboarding: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[companyId: string, tenantId: string], {
+    companyId: string;
+    tenantId: string;
+}, "aiAccountantView/cancelAiAccountantOnboarding", never, never>, cancelAiAccountantOnboardingFailure: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[tenantId: string, error: ZeniAPIStatus<Record<string, unknown>>], {
+    tenantId: string;
+    error: ZeniAPIStatus<Record<string, unknown>>;
+}, "aiAccountantView/cancelAiAccountantOnboardingFailure", never, never>, cancelAiAccountantOnboardingSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[tenantId: string], {
+    tenantId: string;
+}, "aiAccountantView/cancelAiAccountantOnboardingSuccess", never, never>, clearAiAccountantView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiAccountantView/clearAiAccountantView">, fetchAiAccountantCustomers: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiAccountantView/fetchAiAccountantCustomers">, fetchAiAccountantJobs: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[tenantId: string, fetchNextPage?: boolean | undefined], {
+    tenantId: string;
+    fetchNextPage: boolean;
+}, "aiAccountantView/fetchAiAccountantJobs", never, never>, setSelectedTenantIdsForJobTrigger: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "aiAccountantView/setSelectedTenantIdsForJobTrigger">, triggerAiAccountantJob: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[operationType: "onboard" | "offboard" | "retrain" | "full_pipeline" | "cancel_onboarding", startDate: string, endDate: string], {
+    operationType: "onboard" | "offboard" | "retrain" | "full_pipeline" | "cancel_onboarding";
+    startDate: string;
+    endDate: string;
+}, "aiAccountantView/triggerAiAccountantJob", never, never>, triggerAiAccountantJobFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiAccountantView/triggerAiAccountantJobFailure">, triggerAiAccountantJobSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiAccountantView/triggerAiAccountantJobSuccess">, updateAiAccountantCustomers: import("@reduxjs/toolkit").ActionCreatorWithPayload<AiAccountantCustomerPayload[], "aiAccountantView/updateAiAccountantCustomers">, updateAiAccountantCustomersFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiAccountantView/updateAiAccountantCustomersFailure">, updateAiAccountantJobs: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[tenantId: string, nextPageToken?: string | null | undefined], {
+    tenantId: string;
+    nextPageToken: string | null;
+}, "aiAccountantView/updateAiAccountantJobs", never, never>, updateAiAccountantJobsFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+    tenantId: ID;
+}, "aiAccountantView/updateAiAccountantJobsFailure">, updateAiAccountantUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<AiAccountantUIState>, "aiAccountantView/updateAiAccountantUIState">;
+declare const _default: import("redux").Reducer<AiAccountantViewState>;
+export default _default;

package/lib/view/aiAccountantView/aiAccountantViewReducer.js

@@ -0,0 +1,153 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAiAccountantUIState = exports.updateAiAccountantJobsFailure = exports.updateAiAccountantJobs = exports.updateAiAccountantCustomersFailure = exports.updateAiAccountantCustomers = exports.triggerAiAccountantJobSuccess = exports.triggerAiAccountantJobFailure = exports.triggerAiAccountantJob = exports.setSelectedTenantIdsForJobTrigger = exports.fetchAiAccountantJobs = exports.fetchAiAccountantCustomers = exports.clearAiAccountantView = exports.cancelAiAccountantOnboardingSuccess = exports.cancelAiAccountantOnboardingFailure = exports.cancelAiAccountantOnboarding = exports.initialAiAccountantViewState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialAiAccountantViewState = {
+    customersByTenantId: {},
+    customersFetchStatus: { fetchState: 'Not-Started' },
+    selectedTenantIdsForJobTrigger: [],
+    triggerJobStatus: { fetchState: 'Not-Started' },
+    uiState: {
+        filterText: '',
+        filters: {},
+        selectedCustomerTenantId: '',
+        sortKey: 'companyName',
+        sortOrder: 'ascending',
+    },
+};
+const aiAccountantView = (0, toolkit_1.createSlice)({
+    name: 'aiAccountantView',
+    initialState: exports.initialAiAccountantViewState,
+    reducers: {
+        // ── Customers ──
+        fetchAiAccountantCustomers(draft) {
+            draft.customersFetchStatus = { fetchState: 'In-Progress' };
+        },
+        updateAiAccountantCustomers(draft, action) {
+            draft.customersByTenantId = toCustomersByTenantId(action.payload, draft.customersByTenantId);
+            draft.customersFetchStatus = { fetchState: 'Completed' };
+        },
+        updateAiAccountantCustomersFailure(draft, action) {
+            draft.customersFetchStatus = {
+                fetchState: 'Error',
+                error: action.payload,
+            };
+        },
+        // ── Jobs ──
+        fetchAiAccountantJobs: {
+            reducer(draft, action) {
+                const customerView = draft.customersByTenantId[action.payload.tenantId];
+                if (customerView != null) {
+                    customerView.jobsFetchStatus = { fetchState: 'In-Progress' };
+                }
+            },
+            prepare(tenantId, fetchNextPage) {
+                return { payload: { tenantId, fetchNextPage: fetchNextPage ?? false } };
+            },
+        },
+        updateAiAccountantJobs: {
+            reducer(draft, action) {
+                const customerView = draft.customersByTenantId[action.payload.tenantId];
+                if (customerView != null) {
+                    customerView.jobsFetchStatus = { fetchState: 'Completed' };
+                    customerView.jobsPageToken = action.payload.nextPageToken;
+                }
+            },
+            prepare(tenantId, nextPageToken) {
+                return { payload: { tenantId, nextPageToken: nextPageToken ?? null } };
+            },
+        },
+        updateAiAccountantJobsFailure(draft, action) {
+            const customerView = draft.customersByTenantId[action.payload.tenantId];
+            if (customerView != null) {
+                customerView.jobsFetchStatus = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            }
+        },
+        setSelectedTenantIdsForJobTrigger(draft, action) {
+            draft.selectedTenantIdsForJobTrigger = action.payload;
+        },
+        // ── Trigger Job ──
+        triggerAiAccountantJob: {
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.triggerJobStatus = { fetchState: 'In-Progress' };
+            },
+            prepare(operationType, startDate, endDate) {
+                return { payload: { operationType, startDate, endDate } };
+            },
+        },
+        triggerAiAccountantJobSuccess(draft) {
+            draft.triggerJobStatus = { fetchState: 'Completed' };
+        },
+        triggerAiAccountantJobFailure(draft, action) {
+            draft.triggerJobStatus = { fetchState: 'Error', error: action.payload };
+        },
+        // ── Cancel Onboarding ──
+        cancelAiAccountantOnboarding: {
+            reducer(draft, action) {
+                const customerView = draft.customersByTenantId[action.payload.tenantId];
+                if (customerView != null) {
+                    customerView.cancelOnboardingStatus = { fetchState: 'In-Progress' };
+                }
+            },
+            prepare(companyId, tenantId) {
+                return { payload: { companyId, tenantId } };
+            },
+        },
+        cancelAiAccountantOnboardingSuccess: {
+            reducer(draft, action) {
+                const customerView = draft.customersByTenantId[action.payload.tenantId];
+                if (customerView != null) {
+                    customerView.cancelOnboardingStatus = { fetchState: 'Completed' };
+                }
+            },
+            prepare(tenantId) {
+                return { payload: { tenantId } };
+            },
+        },
+        cancelAiAccountantOnboardingFailure: {
+            reducer(draft, action) {
+                const customerView = draft.customersByTenantId[action.payload.tenantId];
+                if (customerView != null) {
+                    customerView.cancelOnboardingStatus = {
+                        fetchState: 'Error',
+                        error: action.payload.error,
+                    };
+                }
+            },
+            prepare(tenantId, error) {
+                return { payload: { tenantId, error } };
+            },
+        },
+        // ── UI State ──
+        updateAiAccountantUIState(draft, action) {
+            Object.assign(draft.uiState, action.payload);
+        },
+        // ── Clear ──
+        clearAiAccountantView() {
+            return exports.initialAiAccountantViewState;
+        },
+    },
+});
+_a = aiAccountantView.actions, exports.cancelAiAccountantOnboarding = _a.cancelAiAccountantOnboarding, exports.cancelAiAccountantOnboardingFailure = _a.cancelAiAccountantOnboardingFailure, exports.cancelAiAccountantOnboardingSuccess = _a.cancelAiAccountantOnboardingSuccess, exports.clearAiAccountantView = _a.clearAiAccountantView, exports.fetchAiAccountantCustomers = _a.fetchAiAccountantCustomers, exports.fetchAiAccountantJobs = _a.fetchAiAccountantJobs, exports.setSelectedTenantIdsForJobTrigger = _a.setSelectedTenantIdsForJobTrigger, exports.triggerAiAccountantJob = _a.triggerAiAccountantJob, exports.triggerAiAccountantJobFailure = _a.triggerAiAccountantJobFailure, exports.triggerAiAccountantJobSuccess = _a.triggerAiAccountantJobSuccess, exports.updateAiAccountantCustomers = _a.updateAiAccountantCustomers, exports.updateAiAccountantCustomersFailure = _a.updateAiAccountantCustomersFailure, exports.updateAiAccountantJobs = _a.updateAiAccountantJobs, exports.updateAiAccountantJobsFailure = _a.updateAiAccountantJobsFailure, exports.updateAiAccountantUIState = _a.updateAiAccountantUIState;
+exports.default = aiAccountantView.reducer;
+// ── Helpers ──
+const toCustomersByTenantId = (customers, existing) => {
+    const result = {};
+    for (const payload of customers) {
+        const tenantId = payload.tenant_id;
+        const existingState = existing[tenantId];
+        result[tenantId] = existingState ?? {
+            cancelOnboardingStatus: { fetchState: 'Not-Started' },
+            jobsFetchStatus: { fetchState: 'Not-Started' },
+            jobsPageToken: null,
+            tenantId,
+        };
+    }
+    return result;
+};

package/lib/view/aiAccountantView/aiAccountantViewSelector.d.ts

@@ -0,0 +1,14 @@
+import { FetchStateAndError } from '../../commonStateTypes/common';
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { AiAccountantCustomerView } from '../../entity/aiAccountantCustomer/aiAccountantCustomerSelector';
+import { RootState } from '../../reducer';
+import { AiAccountantCustomerViewState, AiAccountantUIState } from './aiAccountantViewState';
+export interface AiAccountantCockpitView extends SelectorView {
+    averageAccuracy: number;
+    customers: AiAccountantCustomerView[];
+    customerViewStateByTenantId: Record<string, AiAccountantCustomerViewState>;
+    selectedCustomersForJobTrigger: AiAccountantCustomerView[];
+    triggerJobStatus: FetchStateAndError;
+    uiState: AiAccountantUIState;
+}
+export declare const getAiAccountantCockpitView: (state: RootState) => AiAccountantCockpitView;

package/lib/view/aiAccountantView/aiAccountantViewSelector.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiAccountantCockpitView = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const aiAccountantCustomerSelector_1 = require("../../entity/aiAccountantCustomer/aiAccountantCustomerSelector");
+exports.getAiAccountantCockpitView = (0, toolkit_1.createSelector)((state) => state.aiAccountantViewState, (state) => state.aiAccountantCustomerState, (state) => state.userState, (viewState, customerEntityState, userState) => {
+    const { customersByTenantId, customersFetchStatus, selectedTenantIdsForJobTrigger, triggerJobStatus, uiState, } = viewState;
+    const allCustomers = (0, aiAccountantCustomerSelector_1.getAiAccountantCustomers)(customerEntityState, userState);
+    let filteredCustomers = allCustomers;
+    // Text filter
+    const trimmedFilterText = uiState.filterText.trim();
+    if (trimmedFilterText.length > 0) {
+        const query = trimmedFilterText.toLowerCase();
+        filteredCustomers = filteredCustomers.filter((customer) => customer.companyName.toLowerCase().includes(query) ||
+            customer.tenantId.toLowerCase().includes(query));
+    }
+    // Cockpit filters (e.g. enrollmentStatus)
+    const enrollmentStatusFilter = uiState.filters.categories?.find((category) => category.field === 'enrollmentStatus');
+    if (enrollmentStatusFilter != null &&
+        enrollmentStatusFilter.values.length > 0) {
+        const selectedStatuses = enrollmentStatusFilter.values.map(String);
+        const isEqual = enrollmentStatusFilter.matchingOperator === 'equal';
+        filteredCustomers = filteredCustomers.filter((customer) => {
+            const status = customer.enrollment?.status ?? 'unknown';
+            const matches = selectedStatuses.includes(status);
+            return isEqual ? matches : !matches;
+        });
+    }
+    // Sorting
+    const sortedCustomers = getSortedCustomers(filteredCustomers, uiState.sortKey, uiState.sortOrder);
+    const selectedCustomersForJobTrigger = allCustomers.filter((customer) => selectedTenantIdsForJobTrigger.includes(customer.tenantId));
+    return {
+        averageAccuracy: calcOverallAverageAccuracy(allCustomers),
+        fetchState: customersFetchStatus.fetchState,
+        error: customersFetchStatus.error,
+        customers: sortedCustomers,
+        customerViewStateByTenantId: customersByTenantId,
+        selectedCustomersForJobTrigger,
+        triggerJobStatus,
+        uiState,
+    };
+});
+// ── Helpers ──
+const getSortedCustomers = (customers, sortKey, sortOrder) => {
+    const direction = sortOrder === 'ascending' ? 'asc' : 'desc';
+    return (0, orderBy_1.default)(customers, (customer) => {
+        switch (sortKey) {
+            case 'companyName':
+                return customer.companyName.toLowerCase();
+            case 'status':
+                return (customer.enrollment?.status ?? 'unknown').toLowerCase();
+            case 'bookcloseDate':
+                return customer.bookcloseDate?.valueOf() ?? 0;
+            case 'latestTraining':
+                return customer.enrollment?.latestTraining?.valueOf() ?? 0;
+            case 'latestSync':
+                return customer.enrollment?.latestTransactionSync?.valueOf() ?? 0;
+            case 'accuracy':
+                return customer.averageAccuracy;
+            default:
+                return customer.companyName.toLowerCase();
+        }
+    }, direction);
+};
+const calcOverallAverageAccuracy = (customers) => {
+    const customerAccuracies = customers
+        .map((customer) => customer.averageAccuracy)
+        .filter((accuracy) => accuracy > 0);
+    if (customerAccuracies.length === 0) {
+        return 0;
+    }
+    return (customerAccuracies.reduce((sum, accuracy) => sum + accuracy, 0) /
+        customerAccuracies.length);
+};

package/lib/view/aiAccountantView/aiAccountantViewState.d.ts

@@ -0,0 +1,26 @@
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
+import { SortOrder } from '../../commonStateTypes/selectorTypes/sortOrderTypes';
+import { CockpitFilters } from '../companyView/types/cockpitTypes';
+export type { AiAccountantCustomer, AiAccountantEnrollment, AiAccountantEnrollmentStatus, AiAccountantJob, AiAccountantJobStatus, AiAccountantOperationType, } from '../../entity/aiAccountantCustomer/aiAccountantCustomerState';
+declare const toAiAccountantSortKeyType: (v: string) => "status" | "companyName" | "bookcloseDate" | "accuracy" | "latestTraining" | "latestSync";
+export type AiAccountantSortKey = ReturnType<typeof toAiAccountantSortKeyType>;
+export interface AiAccountantUIState {
+    filters: CockpitFilters;
+    filterText: string;
+    selectedCustomerTenantId: string;
+    sortKey: AiAccountantSortKey;
+    sortOrder: SortOrder;
+}
+export interface AiAccountantCustomerViewState {
+    cancelOnboardingStatus: FetchStateAndError;
+    jobsFetchStatus: FetchStateAndError;
+    jobsPageToken: string | null;
+    tenantId: ID;
+}
+export interface AiAccountantViewState {
+    customersByTenantId: Record<ID, AiAccountantCustomerViewState>;
+    customersFetchStatus: FetchStateAndError;
+    selectedTenantIdsForJobTrigger: ID[];
+    triggerJobStatus: FetchStateAndError;
+    uiState: AiAccountantUIState;
+}

package/lib/view/aiAccountantView/aiAccountantViewState.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stringToUnion_1 = require("../../commonStateTypes/stringToUnion");
+const ALL_AI_ACCOUNTANT_SORT_KEYS = [
+    'companyName',
+    'status',
+    'bookcloseDate',
+    'latestTraining',
+    'latestSync',
+    'accuracy',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toAiAccountantSortKeyType = (v) => (0, stringToUnion_1.stringToUnion)(v, ALL_AI_ACCOUNTANT_SORT_KEYS);

package/lib/view/aiAccountantView/epics/cancelAiAccountantOnboardingEpic.d.ts

@@ -0,0 +1,33 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { cancelAiAccountantOnboarding, cancelAiAccountantOnboardingFailure, cancelAiAccountantOnboardingSuccess, fetchAiAccountantCustomers } from '../aiAccountantViewReducer';
+export type ActionType = ReturnType<typeof cancelAiAccountantOnboarding> | ReturnType<typeof cancelAiAccountantOnboardingSuccess> | ReturnType<typeof cancelAiAccountantOnboardingFailure> | ReturnType<typeof fetchAiAccountantCustomers> | ReturnType<typeof openSnackbar>;
+export declare const cancelAiAccountantOnboardingEpic: (actions$: ActionsObservable<ActionType>, _: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: {
+        messageSection: import("../../..").SnackbarMessageSections;
+        messageText: import("../../..").SnackbarMessageSectionTexts;
+        type: import("../../..").SnackbarMessageType;
+        showStatusIcon?: boolean;
+        variables?: {
+            variableName: string;
+            variableValue: string;
+        }[];
+    };
+    type: "snackbar/openSnackbar";
+} | {
+    payload: {
+        tenantId: string;
+    };
+    type: "aiAccountantView/cancelAiAccountantOnboardingSuccess";
+} | {
+    payload: {
+        tenantId: string;
+        error: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    };
+    type: "aiAccountantView/cancelAiAccountantOnboardingFailure";
+} | {
+    payload: undefined;
+    type: "aiAccountantView/fetchAiAccountantCustomers";
+}>;

package/lib/view/aiAccountantView/epics/cancelAiAccountantOnboardingEpic.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelAiAccountantOnboardingEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../entity/snackbar/snackbarReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const aiAccountantViewReducer_1 = require("../aiAccountantViewReducer");
+const cancelAiAccountantOnboardingEpic = (actions$, _, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiAccountantViewReducer_1.cancelAiAccountantOnboarding.match), (0, operators_1.mergeMap)((action) => {
+    const { tenantId, companyId } = action.payload;
+    const base = `${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels`;
+    const url = `${base}/ai-accountant/cancel-onboarding`;
+    return zeniAPI
+        .postAndGetJSON(url, {
+        tenant_id: tenantId,
+        company_id: companyId,
+    })
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            return (0, rxjs_1.from)([
+                (0, aiAccountantViewReducer_1.cancelAiAccountantOnboardingSuccess)(tenantId),
+                (0, aiAccountantViewReducer_1.fetchAiAccountantCustomers)(),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'common',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        else {
+            return (0, rxjs_1.from)([
+                (0, aiAccountantViewReducer_1.cancelAiAccountantOnboardingFailure)(tenantId, response.status),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'common',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.from)([
+        (0, aiAccountantViewReducer_1.cancelAiAccountantOnboardingFailure)(tenantId, (0, responsePayload_1.createZeniAPIStatus)('Unexpected error', 'AI Accountant cancel onboarding failed: ' +
+            JSON.stringify(error))),
+        (0, snackbarReducer_1.openSnackbar)({
+            messageSection: 'common',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));
+exports.cancelAiAccountantOnboardingEpic = cancelAiAccountantOnboardingEpic;

package/lib/view/aiAccountantView/epics/fetchAiAccountantCustomersEpic.d.ts

@@ -0,0 +1,23 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { updateAiAccountantCustomers as updateAiAccountantCustomerEntities } from '../../../entity/aiAccountantCustomer/aiAccountantCustomerReducer';
+import { updateAllUsers } from '../../../entity/user/userReducer';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchAiAccountantCustomers, updateAiAccountantCustomers, updateAiAccountantCustomersFailure } from '../aiAccountantViewReducer';
+export type ActionType = ReturnType<typeof fetchAiAccountantCustomers> | ReturnType<typeof updateAiAccountantCustomers> | ReturnType<typeof updateAiAccountantCustomersFailure> | ReturnType<typeof updateAiAccountantCustomerEntities> | ReturnType<typeof updateAllUsers>;
+export declare const fetchAiAccountantCustomersEpic: (actions$: ActionsObservable<ActionType>, _: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: {
+        users: import("../../..").UserPayload[];
+        updateType?: import("../../..").UpdateType;
+    };
+    type: "user/updateAllUsers";
+} | {
+    payload: import("../aiAccountantViewPayload").AiAccountantCustomerPayload[];
+    type: "aiAccountantView/updateAiAccountantCustomers";
+} | {
+    payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: "aiAccountantView/updateAiAccountantCustomersFailure";
+} | {
+    payload: import("../aiAccountantViewPayload").AiAccountantCustomerPayload[];
+    type: "aiAccountantCustomer/updateAiAccountantCustomers";
+}>;

package/lib/view/aiAccountantView/epics/fetchAiAccountantCustomersEpic.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAiAccountantCustomersEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const aiAccountantCustomerReducer_1 = require("../../../entity/aiAccountantCustomer/aiAccountantCustomerReducer");
+const userReducer_1 = require("../../../entity/user/userReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const aiAccountantViewReducer_1 = require("../aiAccountantViewReducer");
+const fetchAiAccountantCustomersEpic = (actions$, _, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiAccountantViewReducer_1.fetchAiAccountantCustomers.match), (0, operators_1.switchMap)(() => {
+    const base = `${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels`;
+    const url = `${base}/ai-accountant/customers`;
+    return zeniAPI
+        .getJSON(url)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            const customers = response.data?.customers ?? [];
+            const users = response.data?.users ?? [];
+            return (0, rxjs_1.from)([
+                (0, aiAccountantCustomerReducer_1.updateAiAccountantCustomers)(customers),
+                (0, userReducer_1.updateAllUsers)({ users }),
+                (0, aiAccountantViewReducer_1.updateAiAccountantCustomers)(customers),
+            ]);
+        }
+        else {
+            return (0, rxjs_1.of)((0, aiAccountantViewReducer_1.updateAiAccountantCustomersFailure)(response.status));
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiAccountantViewReducer_1.updateAiAccountantCustomersFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected error', 'AI Accountant customers fetch failed: ' +
+        JSON.stringify(error))))));
+}));
+exports.fetchAiAccountantCustomersEpic = fetchAiAccountantCustomersEpic;

package/lib/view/aiAccountantView/epics/fetchAiAccountantJobsEpic.d.ts

@@ -0,0 +1,33 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { updateAiAccountantJobs as updateAiAccountantJobEntities } from '../../../entity/aiAccountantCustomer/aiAccountantCustomerReducer';
+import { updateAllUsers } from '../../../entity/user/userReducer';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchAiAccountantJobs, updateAiAccountantJobs, updateAiAccountantJobsFailure } from '../aiAccountantViewReducer';
+export type ActionType = ReturnType<typeof fetchAiAccountantJobs> | ReturnType<typeof updateAiAccountantJobs> | ReturnType<typeof updateAiAccountantJobEntities> | ReturnType<typeof updateAiAccountantJobsFailure> | ReturnType<typeof updateAllUsers>;
+export declare const fetchAiAccountantJobsEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: {
+        users: import("../../..").UserPayload[];
+        updateType?: import("../../..").UpdateType;
+    };
+    type: "user/updateAllUsers";
+} | {
+    payload: {
+        tenantId: string;
+        nextPageToken: string | null;
+    };
+    type: "aiAccountantView/updateAiAccountantJobs";
+} | {
+    payload: {
+        tenantId: string;
+        jobs: import("../aiAccountantViewPayload").AiAccountantJobPayload[];
+        append: boolean;
+    };
+    type: "aiAccountantCustomer/updateAiAccountantJobs";
+} | {
+    payload: {
+        error: import("../../../responsePayload").ZeniAPIStatus;
+        tenantId: import("../../..").ID;
+    };
+    type: "aiAccountantView/updateAiAccountantJobsFailure";
+}>;

package/lib/view/aiAccountantView/epics/fetchAiAccountantJobsEpic.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAiAccountantJobsEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const aiAccountantCustomerReducer_1 = require("../../../entity/aiAccountantCustomer/aiAccountantCustomerReducer");
+const userReducer_1 = require("../../../entity/user/userReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const aiAccountantViewReducer_1 = require("../aiAccountantViewReducer");
+const fetchAiAccountantJobsEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(aiAccountantViewReducer_1.fetchAiAccountantJobs.match), (0, operators_1.switchMap)((action) => {
+    const { tenantId, fetchNextPage } = action.payload;
+    const rootState = state$.value;
+    const customerView = rootState.aiAccountantViewState.customersByTenantId[tenantId];
+    const pageToken = fetchNextPage && customerView?.jobsPageToken != null
+        ? customerView.jobsPageToken
+        : null;
+    const params = new URLSearchParams({
+        page_size: '50',
+        tenant_id: tenantId,
+    });
+    if (pageToken != null) {
+        params.set('page_token', pageToken);
+    }
+    const base = `${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels`;
+    const url = `${base}/ai-accountant/jobs?${params.toString()}`;
+    return zeniAPI
+        .getJSON(url)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            const jobs = response.data?.jobs ?? [];
+            const users = response.data?.users ?? [];
+            const nextPageToken = response.data?.next_page_token ?? null;
+            return (0, rxjs_1.from)([
+                (0, userReducer_1.updateAllUsers)({ users }),
+                (0, aiAccountantCustomerReducer_1.updateAiAccountantJobs)(tenantId, jobs, fetchNextPage),
+                (0, aiAccountantViewReducer_1.updateAiAccountantJobs)(tenantId, nextPageToken),
+            ]);
+        }
+        else {
+            return (0, rxjs_1.of)((0, aiAccountantViewReducer_1.updateAiAccountantJobsFailure)({
+                tenantId,
+                error: response.status,
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, aiAccountantViewReducer_1.updateAiAccountantJobsFailure)({
+        tenantId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected error', 'AI Accountant jobs fetch failed: ' +
+            JSON.stringify(error)),
+    }))));
+}));
+exports.fetchAiAccountantJobsEpic = fetchAiAccountantJobsEpic;

package/lib/view/aiAccountantView/epics/triggerAiAccountantJobEpic.d.ts

@@ -0,0 +1,28 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { fetchAiAccountantCustomers, triggerAiAccountantJob, triggerAiAccountantJobFailure, triggerAiAccountantJobSuccess } from '../aiAccountantViewReducer';
+export type ActionType = ReturnType<typeof triggerAiAccountantJob> | ReturnType<typeof triggerAiAccountantJobSuccess> | ReturnType<typeof triggerAiAccountantJobFailure> | ReturnType<typeof fetchAiAccountantCustomers> | ReturnType<typeof openSnackbar>;
+export declare const triggerAiAccountantJobEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: {
+        messageSection: import("../../..").SnackbarMessageSections;
+        messageText: import("../../..").SnackbarMessageSectionTexts;
+        type: import("../../..").SnackbarMessageType;
+        showStatusIcon?: boolean;
+        variables?: {
+            variableName: string;
+            variableValue: string;
+        }[];
+    };
+    type: "snackbar/openSnackbar";
+} | {
+    payload: undefined;
+    type: "aiAccountantView/fetchAiAccountantCustomers";
+} | {
+    payload: undefined;
+    type: "aiAccountantView/triggerAiAccountantJobSuccess";
+} | {
+    payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: "aiAccountantView/triggerAiAccountantJobFailure";
+}>;