remove unnecessary async

apps/web/process/fingap/lib/helper.ts

@@ -0,0 +1,129 @@
+import { calculateFinGAP } from '@/api/core/query';
+import type { RequestFinGAP } from '@/api/core/types';
+import type { Risk } from '@/Components/Calculation/Form/Insurance/FinGAPTable/types';
+import type * as Insurance from '@/Components/Calculation/Form/Insurance/InsuranceTable/types';
+import { STALE_TIME } from '@/constants/request';
+import type * as CRMTypes from '@/graphql/crm.types';
+import type { ProcessContext } from '@/process/types';
+import type { CalculationValues } from '@/stores/calculation/values/types';
+import { gql } from '@apollo/client';
+import type { QueryFunctionContext } from '@tanstack/react-query';
+import dayjs from 'dayjs';
+import { flatten } from 'tools/object';
+
+type GetFingapRisksInputValues = Pick<
+  CalculationValues,
+  'discountRub' | 'firstPaymentRub' | 'leasingPeriod' | 'plPriceRub'
+>;
+
+type GetFingapRisksInsuranceValues = {
+  fingap: Pick<Insurance.RowValues, 'insuranceCompany'>;
+};
+
+type GetFingapRisksPaymentsValues = {
+  values: number[];
+};
+
+const QUERY_GET_FINGAP_ADDPRODUCT_TYPES = gql`
+  query GetFinGAPAddProductTypes($currentDate: DateTime) {
+    evo_addproduct_types(
+      statecode: 0
+      evo_datefrom_param: { lte: $currentDate }
+      evo_dateto_param: { gte: $currentDate }
+      evo_product_type: 100000006
+    ) {
+      evo_addproduct_typeid
+      evo_name
+      evo_type_calc_cerebellum
+      evo_cost_service_provider_withoutnds
+      evo_addproduct_types {
+        evo_addproduct_typeid
+      }
+    }
+  }
+`;
+
+export default function helper({
+  apolloClient,
+  queryClient,
+}: Pick<ProcessContext, 'apolloClient' | 'queryClient'>) {
+  return {
+    async getFingapRisks(
+      { discountRub, firstPaymentRub, leasingPeriod, plPriceRub }: GetFingapRisksInputValues,
+      insurance: GetFingapRisksInsuranceValues,
+      payments: GetFingapRisksPaymentsValues
+    ) {
+      const {
+        data: { evo_addproduct_types },
+      } = await apolloClient.query<
+        CRMTypes.GetFinGapAddProductTypesQuery,
+        CRMTypes.GetFinGapAddProductTypesQueryVariables
+      >({
+        query: QUERY_GET_FINGAP_ADDPRODUCT_TYPES,
+        variables: {
+          currentDate: dayjs().utc(false).toISOString(),
+        },
+      });
+
+      const risks = evo_addproduct_types?.map(
+        (evo_addproduct_type) =>
+          ({
+            calcType: evo_addproduct_type?.evo_type_calc_cerebellum,
+            key: evo_addproduct_type?.evo_addproduct_typeid,
+            keys: evo_addproduct_type?.evo_addproduct_types?.map(
+              (addproduct_type) => addproduct_type?.evo_addproduct_typeid
+            ),
+            premium: 0,
+            premiumPerc: evo_addproduct_type?.evo_cost_service_provider_withoutnds,
+            riskId: evo_addproduct_type?.evo_addproduct_typeid,
+            riskName: evo_addproduct_type?.evo_name,
+            sum: 0,
+          } as Risk)
+      );
+
+      if (!risks) return [];
+
+      function getFingapRequestDataFromRisk(risk: Risk): RequestFinGAP {
+        return {
+          calcType: risk.calcType,
+          payments: payments.values.map((payment) => ({
+            percentPayment: payment,
+          })),
+          values: {
+            discount: discountRub,
+            firstPayment: firstPaymentRub,
+            leasingPeriod,
+            plPrice: plPriceRub,
+            premiumPerc: risk.premiumPerc || 0,
+          },
+        };
+      }
+
+      // eslint-disable-next-line unicorn/consistent-function-scoping
+      function makeRequestGetFinGAP(request: RequestFinGAP) {
+        const queryCalculateFinGAP = (context: QueryFunctionContext) =>
+          calculateFinGAP(request, context);
+
+        return queryClient.fetchQuery(
+          ['core', 'fingap', ...flatten(request)],
+          queryCalculateFinGAP,
+          {
+            staleTime: STALE_TIME,
+          }
+        );
+      }
+
+      return Promise.all(
+        risks
+          .map((risk) => getFingapRequestDataFromRisk(risk))
+          .map((data) => makeRequestGetFinGAP(data))
+      ).then((results) =>
+        risks.map((risk, i) => ({
+          ...risk,
+          premium: results.at(i)?.premium || 0,
+          sum: results.at(i)?.sum || 0,
+        }))
+      );
+    },
+  };
+}

apps/web/process/fingap/reactions/common.ts

@@ -1,26 +1,25 @@
-import { calculateFinGAP } from '@/api/core/query';
+import helper from '../lib/helper';
-import type { RequestFinGAP } from '@/api/core/types';
-import type { Risk } from '@/Components/Calculation/Form/Insurance/FinGAPTable/types';
-import { STALE_TIME } from '@/constants/request';
-import type * as CRMTypes from '@/graphql/crm.types';
 import type { ProcessContext } from '@/process/types';
 import { disposableReaction } from '@/utils/mobx';
-import { gql } from '@apollo/client';
-import type { QueryFunctionContext } from '@tanstack/react-query';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc';
-import { comparer, reaction, toJS } from 'mobx';
+import { comparer, reaction } from 'mobx';
-import { flatten } from 'tools/object';
 
 dayjs.extend(utc);
 
 export default function reactions({ store, apolloClient, queryClient }: ProcessContext) {
+  const { getFingapRisks } = helper({ apolloClient, queryClient });
+
   const { $calculation, $tables, $process } = store;
   // Расчет итоговой суммы ФинГАП и запись в таблицу страхования
-  reaction(
+  disposableReaction(
+    () => $process.has('LoadKP'),
     () => $tables.fingap.totalSum,
     (totalSum) => {
       $tables.insurance.row('fingap').setValue('insCost', totalSum);
+    },
+    {
+      delay: 50,
     }
   );
 
@@ -82,32 +81,13 @@ export default function reactions({ store, apolloClient, queryClient }: ProcessC
     }
   );
 
-  const QUERY_GET_FINGAP_ADDPRODUCT_TYPES = gql`
-    query GetFinGAPAddProductTypes($currentDate: DateTime) {
-      evo_addproduct_types(
-        statecode: 0
-        evo_datefrom_param: { lte: $currentDate }
-        evo_dateto_param: { gte: $currentDate }
-        evo_product_type: 100000006
-      ) {
-        evo_addproduct_typeid
-        evo_name
-        evo_type_calc_cerebellum
-        evo_cost_service_provider_withoutnds
-        evo_addproduct_types {
-          evo_addproduct_typeid
-        }
-      }
-    }
-  `;
-
   // Заполнение таблицы рисков ФинГАП + Запрос расчета финГАП в мозжечок
 
   disposableReaction(
     () => $process.has('Calculate'),
     () => {
       const finGAPInsuranceCompany = $tables.insurance.row('fingap').getValue('insuranceCompany');
-      const paymentsValues = toJS($tables.payments.values);
+      const paymentsValues = $tables.payments.getValues;
       const plPriceRub = $calculation.$values.getValue('plPriceRub');
       const discountRub = $calculation.$values.getValue('discountRub');
       const firstPaymentRub = $calculation.element('tbxFirstPaymentRub').getValue();
@@ -124,7 +104,7 @@ export default function reactions({ store, apolloClient, queryClient }: ProcessC
         plPriceRub,
       };
     },
-    async ({
+    ({
       finGAPInsuranceCompany,
       paymentsValues,
       plPriceRub,
@@ -139,81 +119,22 @@ export default function reactions({ store, apolloClient, queryClient }: ProcessC
         return;
       }
 
-      const {
+      getFingapRisks(
-        data: { evo_addproduct_types },
+        {
-      } = await apolloClient.query<
+          discountRub,
-        CRMTypes.GetFinGapAddProductTypesQuery,
+          firstPaymentRub,
-        CRMTypes.GetFinGapAddProductTypesQueryVariables
+          leasingPeriod,
-      >({
+          plPriceRub,
-        query: QUERY_GET_FINGAP_ADDPRODUCT_TYPES,
-        variables: {
-          currentDate: dayjs().utc(false).toISOString(),
         },
-      });
+        { fingap: { insuranceCompany: finGAPInsuranceCompany } },
-
+        { values: paymentsValues }
-      const risks = evo_addproduct_types?.map(
-        (evo_addproduct_type) =>
-          ({
-            calcType: evo_addproduct_type?.evo_type_calc_cerebellum,
-            key: evo_addproduct_type?.evo_addproduct_typeid,
-            keys: evo_addproduct_type?.evo_addproduct_types?.map(
-              (addproduct_type) => addproduct_type?.evo_addproduct_typeid
-            ),
-            premium: 0,
-            premiumPerc: evo_addproduct_type?.evo_cost_service_provider_withoutnds,
-            riskId: evo_addproduct_type?.evo_addproduct_typeid,
-            riskName: evo_addproduct_type?.evo_name,
-            sum: 0,
-          } as Risk)
-      );
-
-      if (!risks) return;
-
-      // $tables.fingap.setRisks(risks);
-
-      function getFingapRequestDataFromRisk(risk: Risk): RequestFinGAP {
-        return {
-          calcType: risk.calcType,
-          payments: paymentsValues.map((payment) => ({
-            percentPayment: payment,
-          })),
-          values: {
-            discount: discountRub,
-            firstPayment: firstPaymentRub,
-            leasingPeriod,
-            plPrice: plPriceRub,
-            premiumPerc: risk.premiumPerc || 0,
-          },
-        };
-      }
-
-      // eslint-disable-next-line unicorn/consistent-function-scoping
-      function makeRequestGetFinGAP(request: RequestFinGAP) {
-        const queryCalculateFinGAP = (context: QueryFunctionContext) =>
-          calculateFinGAP(request, context);
-
-        return queryClient.fetchQuery(
-          ['core', 'fingap', ...flatten(request)],
-          queryCalculateFinGAP,
-          {
-            staleTime: STALE_TIME,
-          }
-        );
-      }
-
-      Promise.all(
-        risks
-          .map((risk) => getFingapRequestDataFromRisk(risk))
-          .map((data) => makeRequestGetFinGAP(data))
       )
-        .then((results) => {
+        .then((risks) => {
-          const newRisks = risks.map((risk, i) => ({
+          if (risks?.length) {
-            ...risk,
+            $tables.fingap.setRisks(risks);
-            premium: results.at(i)?.premium || 0,
+          } else {
-            sum: results.at(i)?.sum || 0,
+            $tables.fingap.clear();
-          }));
+          }
-
-          $tables.fingap.setRisks(newRisks);
         })
         .catch(() => {
           $tables.fingap.clear();

apps/web/process/insurance/get-kp-data.ts

@@ -1,10 +1,18 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import helper from '../fingap/lib/helper';
 import type { GetQuoteInputData, GetQuoteProcessData } from '../load-kp/types';
 import initializeApollo from '@/apollo/client';
 import defaultValues from '@/config/default-values';
 import * as insuranceTable from '@/config/tables/insurance-table';
 import * as CRMTypes from '@/graphql/crm.types';
+import { getKPData as getKPDataFingap } from '@/process/fingap/get-kp-data';
+import { getKPData as getKPDataPayments } from '@/process/payments/get-kp-data';
+import { getKPData as getKPDataPrice } from '@/process/price/get-kp-data';
+import { createCurrencyUtility } from '@/utils/currency';
 import { gql } from '@apollo/client';
+import { QueryClient } from '@tanstack/react-query';
+import { sum } from 'radash';
 
 const { DEFAULT_FINGAP_ROW, DEFAULT_KASKO_ROW, DEFAULT_OSAGO_ROW } = insuranceTable;
 
@@ -34,10 +42,13 @@ const QUERY_GET_QUOTE_INSURANCE_DATA = gql`
   }
 `;
 
-export async function getKPData({
+export async function getKPData({ values }: GetQuoteInputData): Promise<GetQuoteProcessData> {
-  values: { quote: quoteId },
+  const { quote: quoteId } = values;
-}: GetQuoteInputData): Promise<GetQuoteProcessData> {
+
   const apolloClient = initializeApollo();
+  const queryClient = new QueryClient();
+
+  const { getFingapRisks } = helper({ apolloClient, queryClient });
 
   const {
     data: { quote },
@@ -48,11 +59,56 @@ export async function getKPData({
     },
   });
 
+  const kpDataPrice = await getKPDataPrice({ values });
+  const kpDataPayments = await getKPDataPayments({ values });
+  const kpDataFingap = await getKPDataFingap({ values });
+
+  const leaseObjectPrice = kpDataPrice.values?.leaseObjectPrice ?? defaultValues.leaseObjectPrice;
+  const firstPaymentRub = kpDataPrice.values?.firstPaymentRub ?? defaultValues.firstPaymentRub;
+  const supplierCurrency = kpDataPrice.values?.supplierCurrency ?? defaultValues.supplierCurrency;
+  const supplierDiscountRub =
+    kpDataPrice.values?.supplierDiscountRub ?? defaultValues.supplierDiscountRub;
+  const leasingPeriod = kpDataPayments.values?.leasingPeriod ?? defaultValues.leasingPeriod;
+
+  const { RUB } = createCurrencyUtility({ apolloClient });
+
+  let plPriceRub = 0;
+  if (supplierCurrency && leaseObjectPrice) {
+    plPriceRub = await RUB({
+      currencyid: supplierCurrency,
+      value: leaseObjectPrice,
+    });
+  }
+
+  let discountRub = 0;
+  if (supplierCurrency && supplierDiscountRub) {
+    discountRub = await RUB({
+      currencyid: supplierCurrency,
+      value: supplierDiscountRub,
+    });
+  }
+
+  const risks = await getFingapRisks(
+    {
+      discountRub,
+      firstPaymentRub,
+      leasingPeriod,
+      plPriceRub,
+    },
+    { fingap: { insuranceCompany: quote?.evo_fingap_accountid ?? null } },
+    { values: kpDataPayments.payments?.values ?? [] }
+  );
+
+  const fingapInsCost = sum(
+    risks.filter((x) => kpDataFingap.fingap?.keys.includes(x.key)),
+    (risk) => risk.premium
+  );
+
   return {
     insurance: {
       values: {
         fingap: Object.assign(DEFAULT_FINGAP_ROW, {
-          insCost: quote?.evo_fingap_price ?? DEFAULT_FINGAP_ROW.insCost,
+          insCost: fingapInsCost ?? DEFAULT_FINGAP_ROW.insCost,
           insTerm: quote?.evo_fingap_period,
           insuranceCompany: quote?.evo_fingap_accountid,
           insured: quote?.evo_fingap_payer,

apps/web/stores/tables/fingap/index.ts

@@ -44,7 +44,7 @@ export default class FinGAPTable {
   };
 
   public get totalSum() {
-    return this.risks
+    return toJS(this.risks)
       .filter((risk) => this.selectedKeys.has(risk.key))
       .reduce((sum, risk) => sum + risk.premium, 0);
   }