@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI10

package/lib/esm/view/transactionDetail/epics/saveTransactionHelper.js

@@ -0,0 +1,305 @@
+import { getRecommendationAmountRange, } from '../../../commonStateTypes/recommendationBase';
+import { toJEAndDepositTransactionTypeStrict, toVendorTransactionTypeStrict, } from '../../../entity/transaction/stateTypes/transactionType';
+import { isVendorTransaction, } from '../../../entity/transaction/stateTypes/vendorTransaction';
+import { convertCOTRecommendationsToRegular } from '../../../entity/transaction/transactionHelper';
+import { getEntityRecommendationKey, } from '../../recommendation/recommendationState';
+import { isAccountUncategorized } from '../transactionDetailLocalDataHelper';
+// This function will extract the data that will determine which all APIs need to be called
+/**
+ *
+ * @param transactionDetailLocalData
+ * Uncategorized transaction
+ * 1. Update transaction with recommended (either historical/most recently used) ->
+ * 1a. Only fire transaction save.
+ * 2. Update transaction with recommended category but different class ->
+ * 2a. fire updateRecommendation with both category & Class chosen.
+ * 2b. Fire transaction Save with chosen recommendations,
+ * 3. Update transaction with recommended category, different class, check update all ->
+ * 3a. fire updateRecommendation with both category & Class chosen.
+ * 3b. Fire transaction save with chosen recommendation
+ * 3c. Fire bulk update with all Amounts
+ * 4. Only difference between this and Miscategorized will be that we will
+ * additionally fire “Mark as not miscat” for every point above.
+ */
+export const toTransactionUpdatesFromTransactionDetailLocalData = (transactionDetailLocalData, transaction, isExpenseAutomationEnabled) => {
+    const updates = {
+        updatesByLineId: {},
+    };
+    const updatesByLineId = {};
+    const entityUpdates = {};
+    const isTransactionMisCategorized = isTransactionMiscategorized(transaction, isExpenseAutomationEnabled);
+    updates.memo = transactionDetailLocalData.memo;
+    updates.documentId = transactionDetailLocalData.documentId;
+    const selectedEntity = transactionDetailLocalData.selectedEntity;
+    const updatedEntityId = transactionDetailLocalData.updatePreviousTransactionsWithUpdatedVendor ===
+        true
+        ? transactionDetailLocalData.vendorUpdates?.qboId
+        : undefined;
+    let isBulkUpdate = false;
+    let lastUpdatedCategory;
+    let lastUpdatedClass;
+    // single recommendation to just pick the last recommendation in the list of lines
+    transaction.lines?.forEach((line) => {
+        const lineItem = transactionDetailLocalData.lineItemById[line.id];
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            if (lineItem == null) {
+                return;
+            }
+            const entityDetails = getEntityDetails(selectedEntity, lineItem, transactionDetailLocalData.vendorUpdates, transactionDetailLocalData.customerUpdates);
+            updatesByLineId[line.id] = {
+                lineDescription: lineItem.lineDescription,
+                class: lineItem.class,
+                account: lineItem.account,
+                project: lineItem.project,
+                recommendation: convertCOTRecommendationsToRegular(lineItem.recommendationsWithCOT),
+            };
+            if (line.type === 'journal_entry_transaction_line' ||
+                line.platformLineDetailType === 'deposit_line_detail') {
+                const currentSelectedEntityLine = lineItem.lineEntity;
+                updatesByLineId[line.id] = {
+                    ...updatesByLineId[line.id],
+                    customer: currentSelectedEntityLine != null &&
+                        currentSelectedEntityLine.type === 'customer'
+                        ? lineItem.customer
+                        : undefined,
+                    vendor: currentSelectedEntityLine != null &&
+                        currentSelectedEntityLine.type === 'vendor'
+                        ? lineItem.vendor
+                        : undefined,
+                };
+            }
+            let hasCategoryChanged = false;
+            let hasClassChanged = false;
+            const accountLine = line;
+            hasCategoryChanged =
+                lineItem.account?.qboId !== accountLine.account.qboId &&
+                    Boolean(lineItem.account?.qboId);
+            hasClassChanged =
+                (lineItem.class?.qboId != null || accountLine.class?.qboId != null) &&
+                    lineItem.class?.qboId !== accountLine.class?.qboId;
+            const recommendedAccountBase = toRecommendedAccountBase(lineItem.amount.amount, lineItem.account);
+            const recommendedClassBase = toRecommendedClassBase(lineItem.amount.amount, lineItem.class);
+            const latestRecommendedCategory = lineItem.recommendedAccount;
+            const latestrecommendedClass = lineItem.recommendedClass;
+            // If at any time the recommended category selected is different from the most recent
+            const isMostRecentRecommendedCategorySelected = Boolean(recommendedAccountBase) &&
+                Boolean(latestRecommendedCategory) &&
+                recommendedAccountBase?.qboId === latestRecommendedCategory?.qboId;
+            // If at any time the recommended class selected is different from the most recent
+            const isMostRecentRecommendedClassSelected = Boolean(recommendedClassBase) &&
+                Boolean(latestrecommendedClass) &&
+                recommendedClassBase?.qboId === latestrecommendedClass?.qboId;
+            const recommendationToBeUpdated = (lineItem.isRecommendedCategorySelected === false ||
+                lineItem.isRecommendedClassSelected === false ||
+                isMostRecentRecommendedCategorySelected === false ||
+                isMostRecentRecommendedClassSelected === false) &&
+                lineItem.recommendationsWithCOT != null &&
+                (hasCategoryChanged || hasClassChanged);
+            // If any bulkUpdate is true, call bulk update
+            isBulkUpdate = isBulkUpdate || (lineItem.isUpdateAllChecked ?? false);
+            if (entityDetails != null &&
+                (recommendationToBeUpdated === true ||
+                    (lineItem.isUpdateAllChecked != null &&
+                        lineItem.isUpdateAllChecked === true) ||
+                    updatedEntityId !== null)) {
+                lastUpdatedCategory =
+                    hasCategoryChanged === true ||
+                        lineItem.isRetainedCategorySelected === true
+                        ? recommendedAccountBase
+                        : undefined;
+                lastUpdatedClass =
+                    hasClassChanged === true || lineItem.isRetainedClassSelected === true
+                        ? recommendedClassBase
+                        : undefined;
+                // Category might have been recommended one, and class may not have been updated and was undefined
+                // in this case check for each
+                const recommended = {
+                    account: lastUpdatedCategory,
+                    class: lastUpdatedClass,
+                };
+                if (recommended.class != null ||
+                    recommended.account != null ||
+                    updatedEntityId != null) {
+                    const vendorIdToUpdate = transactionDetailLocalData.vendorUpdates?.qboId;
+                    const customerIdToUpdate = transactionDetailLocalData.customerUpdates?.qboId;
+                    let entityId = entityDetails.entityId;
+                    if (vendorIdToUpdate != null && selectedEntity?.type === 'vendor') {
+                        entityId =
+                            transactionDetailLocalData.updatePreviousTransactionsWithUpdatedVendor ===
+                                true
+                                ? entityId
+                                : vendorIdToUpdate;
+                    }
+                    else {
+                        if (customerIdToUpdate != null &&
+                            selectedEntity?.type === 'customer') {
+                            entityId = customerIdToUpdate;
+                        }
+                    }
+                    doUpdateEntityUpdates(entityUpdates, entityId, entityDetails.entityType, recommended, lineItem.isUpdateAllChecked, updatedEntityId, entityDetails.entityName);
+                }
+            }
+        }
+        else {
+            updatesByLineId[line.id] = line;
+        }
+    });
+    updates.updatesByLineId = updatesByLineId;
+    return {
+        updates,
+        entityRelatedUpdates: entityUpdates,
+        /*Note: We need to call `mark-miscategorized-as-correct` api only when any of the line item is miscategorized
+        and all the line items are NOT uncategorized*/
+        markAsMiscatUpdates: isTransactionMisCategorized,
+        anyBulkUpdates: isBulkUpdate,
+    };
+};
+const doUpdateEntityUpdates = (entityUpdates, entityId, entityType, recommendation, isBulkUpdate = false, updatedEntityId, entityName) => {
+    // see if this entity is already being updated
+    const entityKey = getEntityRecommendationKey(entityType, entityId ?? entityName);
+    const entityUpdate = entityUpdates[entityKey];
+    const commonUpdate = {
+        recommendations: recommendation,
+        entityId: entityId === entityName ? null : entityId,
+        ...(entityType === 'vendor' && entityName != null
+            ? { vendorName: entityName }
+            : {}),
+    };
+    if (entityUpdate == null) {
+        entityUpdates[entityKey] = {
+            entityType,
+            isBulkUpdate,
+            updatedEntityId,
+            ...commonUpdate,
+        };
+    }
+    else {
+        entityUpdates[entityKey] = {
+            ...entityUpdate,
+            ...commonUpdate,
+        };
+    }
+};
+export const toRecommendedAccountBase = (amountValue, accountBase, recommendationBase) => {
+    if (accountBase != null && recommendationBase != null) {
+        return {
+            ...accountBase,
+            min: recommendationBase.min,
+            max: recommendationBase.max,
+            reason: recommendationBase.reason,
+            type: recommendationBase.type,
+        };
+    }
+    else if (accountBase != null) {
+        const { min, max } = getRecommendationAmountRange(amountValue);
+        return {
+            ...accountBase,
+            min,
+            max,
+            reason: '',
+            type: '',
+        };
+    }
+    else {
+        return undefined;
+    }
+};
+export const toRecommendedClassBase = (amountValue, classBase, recommendationBase) => {
+    if (classBase != null && recommendationBase != null) {
+        return {
+            ...classBase,
+            min: recommendationBase.min,
+            max: recommendationBase.max,
+            reason: recommendationBase.reason,
+            type: recommendationBase.type,
+        };
+    }
+    else if (classBase != null) {
+        const { min, max } = getRecommendationAmountRange(amountValue);
+        return {
+            ...classBase,
+            min,
+            max,
+            reason: '',
+            type: '',
+        };
+    }
+    else {
+        return undefined;
+    }
+};
+const getEntityDetails = (entity, lineItemLocalData, vendorUpdates, customerUpdates) => {
+    if (entity != null) {
+        return {
+            entityId: entity.qboId ?? entity.id,
+            entityType: entity.type,
+            entityName: entity.name,
+        };
+    }
+    if (lineItemLocalData?.lineEntity != null) {
+        return {
+            entityId: lineItemLocalData.lineEntity.qboId ?? lineItemLocalData.lineEntity.id,
+            entityType: lineItemLocalData.lineEntity.type,
+            entityName: lineItemLocalData.lineEntity.name,
+        };
+    }
+    if (customerUpdates != null &&
+        Boolean(customerUpdates.id) === true &&
+        customerUpdates.id != null) {
+        return {
+            entityId: customerUpdates.id,
+            entityType: 'customer',
+        };
+    }
+    if (vendorUpdates != null) {
+        return {
+            entityId: vendorUpdates.qboId ?? vendorUpdates.id ?? vendorUpdates.name,
+            entityType: 'vendor',
+            entityName: vendorUpdates.name,
+        };
+    }
+    return undefined;
+};
+export const isTransactionMiscategorized = (transaction, isExpenseAutomationEnabled) => {
+    const lines = transaction.lines;
+    if (isExpenseAutomationEnabled === true &&
+        (isVendorTransaction(transaction) || transaction.type === 'journal_entry')) {
+        return true;
+    }
+    let isTransactionMisCategorized = false;
+    lines?.forEach((line) => {
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = line;
+            if (lineItem.isCategoryMiscategorized ||
+                lineItem.isClassMiscategorized ||
+                // This ensures that neither vendor or customer is present at line level, safe to say miscat line due to vendor/customer
+                (toVendorTransactionTypeStrict(transaction.type) &&
+                    transaction.vendor == null) ||
+                (toJEAndDepositTransactionTypeStrict(transaction.type) &&
+                    lineItem.vendor == null &&
+                    lineItem.customer == null)) {
+                isTransactionMisCategorized = true;
+            }
+        }
+    });
+    return isTransactionMisCategorized;
+};
+export const isTransactionUncategorized = (transaction, uncategorizedIncomeExpense) => {
+    const lines = transaction.lines;
+    let isTransactionUnCategorized = false;
+    lines?.forEach((line) => {
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = line;
+            if (isAccountUncategorized(uncategorizedIncomeExpense, lineItem.account.qboId)) {
+                isTransactionUnCategorized = true;
+            }
+        }
+    });
+    return isTransactionUnCategorized;
+};

package/lib/esm/view/transactionDetail/epics/transactionDetailEpic.js

@@ -0,0 +1,134 @@
+import recordGet from 'lodash/get';
+import { concat, from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { toTransactionID } from '../../../entity/transaction/payloadTypes/transactionIDPayload';
+import { toTransaction, } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { toVendorTransactionTypeStrict } from '../../../entity/transaction/stateTypes/transactionType';
+import { removeTransaction, updateTransaction, } from '../../../entity/transaction/transactionReducer';
+import { getSupportedTransactionById } from '../../../entity/transaction/transactionSelector';
+import { mapVendorPayloadToVendor } from '../../../entity/vendor/vendorPayload';
+import { updateVendors } from '../../../entity/vendor/vendorReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchAccountList } from '../../accountList/accountListReducer';
+import { fetchClassList } from '../../classList/classListReducer';
+import { getInitializedTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorLocalDataHelper';
+import { updateTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorViewReducer';
+import { fetchOwnerList } from '../../ownerList/ownerListReducer';
+import { fetchProjectList } from '../../projectList/projectListReducer';
+import { fetchTransactionDetail, initializeTransactionDetailLocalData, removeTransactionDetail, updateTransactionDetailFetchState, } from '../transactionDetailReducer';
+import { getAllLinkedTransactions, getTransactionDetailKey, } from '../transactionDetailState';
+export const fetchTransactionDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTransactionDetail.match), mergeMap((action) => {
+    const { transactionId, cacheOverride } = action.payload;
+    const detailKey = getTransactionDetailKey(transactionId);
+    const transactionActions = [];
+    if (cacheOverride === true) {
+        const transaction = getSupportedTransactionById(state$.value.transactionState, detailKey);
+        transactionActions.push(...removeCompleteTransaction(transactionId, transaction));
+    }
+    const transactionDetail = recordGet(state$.value.transactionDetailState.transactionDetailById, detailKey, undefined);
+    if (cacheOverride === true ||
+        transactionDetail == null ||
+        (transactionDetail.hasValidState() === false &&
+            transactionDetail.fetchState !== 'In-Progress')) {
+        const accountList = state$.value.accountListState.byReportId.accountList;
+        if (accountList.hasValidState() === false &&
+            accountList.fetchState !== 'In-Progress') {
+            transactionActions.push(fetchAccountList('accountList'));
+        }
+        const classList = state$.value.classListState;
+        if (classList.hasValidState() === false &&
+            classList.fetchState !== 'In-Progress') {
+            transactionActions.push(fetchClassList());
+        }
+        const projectList = state$.value.projectListState;
+        if (projectList.hasValidState() === false &&
+            projectList.fetchState !== 'In-Progress') {
+            transactionActions.push(fetchProjectList());
+        }
+        transactionActions.push(updateTransactionDetailFetchState(transactionId, 'In-Progress'));
+        const query = { transaction_type: transactionId.type };
+        const getTransactionDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/${transactionId.id}?query=${encodeURIComponent(JSON.stringify(query))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) &&
+                response.data?.transaction?.transaction_id != null) {
+                const updateActions = [];
+                const transcationId = toTransactionID(response.data.transaction);
+                const responseData = {
+                    ...response.data,
+                    vendors: response.data.vendors?.map((vendor) => ({
+                        ...vendor,
+                        vendor_id: vendor.qbo_id ?? vendor.vendor_id,
+                    })) ?? [],
+                };
+                if (responseData.vendors.length > 0) {
+                    updateActions.push(updateVendors(responseData.vendors, 'merge'));
+                }
+                const transactionDetailKeyForResponse = getTransactionDetailKey(transcationId);
+                updateActions.push(updateTransaction(transactionDetailKeyForResponse, responseData.transaction));
+                updateActions.push(initializeTransactionDetailLocalData({
+                    transactionId: transcationId,
+                    vendorId: responseData.vendors[0]?.vendor_id,
+                }));
+                updateActions.push(updateTransactionDetailFetchState(transcationId, 'Completed'));
+                // IMPORTANT: Fetch linked transactions..
+                updateActions.push(...getAllFetchLinkedTransactionDetailActions(responseData.transaction, state$.value));
+                if (responseData.vendors.length > 0) {
+                    updateActions.push(updateTransactionVendorLocalData({
+                        vendorId: responseData.vendors[0].vendor_id,
+                        localData: getInitializedTransactionVendorLocalData(mapVendorPayloadToVendor(responseData.vendors[0])),
+                    }));
+                }
+                // If vendor transaction, fetch owners list
+                if (toVendorTransactionTypeStrict(responseData.transaction.transaction_type) != null) {
+                    updateActions.push(fetchOwnerList());
+                }
+                return from(updateActions);
+            }
+            else {
+                return of(updateTransactionDetailFetchState(action.payload.transactionId, 'Error', response.status));
+            }
+        }), catchError((error) => {
+            console.error(`REST API call errored out ${error}`);
+            return of(updateTransactionDetailFetchState(action.payload.transactionId, 'Error', createZeniAPIStatus('Unexpected Error', `REST API call errored out ${error}`)));
+        }));
+        return concat(from(transactionActions), getTransactionDetail$);
+    }
+    else {
+        return from(transactionActions);
+    }
+}));
+/**
+ * Helper functions
+ */
+function removeCompleteTransaction(transactionId, transaction) {
+    const actions = [];
+    actions.push(removeTransactionDetail(transactionId));
+    if (transaction != null) {
+        actions.push(removeTransaction(getTransactionDetailKey(transactionId)));
+        // remove all the linked transactions too..
+        const linkedTransactions = getAllLinkedTransactions(transaction);
+        linkedTransactions.forEach((linkedTransaction) => {
+            actions.push(removeTransactionDetail(linkedTransaction));
+            actions.push(removeTransaction(getTransactionDetailKey(linkedTransaction)));
+        });
+    }
+    return actions;
+}
+function isTransactionDetailInCacheOrFetching(transactionId, state) {
+    const detailKey = getTransactionDetailKey(transactionId);
+    const detail = state.transactionDetailState.transactionDetailById[detailKey];
+    return (detail != null &&
+        (detail.hasValidState() === true || detail.fetchState === 'In-Progress'));
+}
+function getAllFetchLinkedTransactionDetailActions(transactionPayload, state) {
+    const fetchLinkedTransactionActions = [];
+    const currentTransaction = toTransaction(transactionPayload);
+    const linkedTransaction = getAllLinkedTransactions(currentTransaction);
+    const linkedTransactionFiltered = linkedTransaction.filter((value) => isTransactionDetailInCacheOrFetching(value, state) === false);
+    linkedTransactionFiltered.forEach((transactionDetailToFetch) => fetchLinkedTransactionActions.push(fetchTransactionDetail(transactionDetailToFetch, false)));
+    if (linkedTransactionFiltered.length === 0) {
+        console.log('Phew all linked transactions are fetched or there are no linked transactions..');
+    }
+    return fetchLinkedTransactionActions;
+}