EvoCalculator.Client2/apps/web/process/elt/lib/response.ts

/* eslint-disable sonarjs/cognitive-complexity */
/* eslint-disable complexity */
import type { ownOsagoRequest } from './request';
import { getInsuranceRule } from './tools';
import type { BaseConvertResponseInput } from './types';
import type * as ELT from '@/api/elt/types';
import type { Row } from '@/Components/Calculation/Form/ELT/types';
import { MAX_FRANCHISE, MAX_INSURANCE, MIN_INSURANCE } from '@/constants/values';
import * as CRMTypes from '@/graphql/crm.types';
import { defaultRow } from '@/stores/tables/elt/default-values';
import { round } from 'tools';

type ConvertEltOsagoResponseInput = BaseConvertResponseInput & {
  response: ELT.ResponseEltOsago;
};

export async function convertEltOsagoResponse(input: ConvertEltOsagoResponseInput): Promise<Row> {
  const { context, response, row } = input;
  const { store } = context;

  const { premiumSum = 0 } = response;
  let { message, numCalc, skCalcId, error } = response;
  let sum = premiumSum;

  const { $calculation } = store;

  const cost =
    $calculation.$values.getValue('plPriceRub') -
    $calculation.$values.getValue('discountRub') -
    $calculation.$values.getValue('importProgramSum') +
    $calculation.$values.getValue('addEquipmentPrice');

  const selectedRule = await getInsuranceRule(input, { cost, riskType: 'osago' });

  const insuranceCondition = selectedRule?.evo_id ?? null;

  if (selectedRule) {
    const rule_evo_discount = selectedRule.evo_discount ?? 0;

    switch (selectedRule.evo_rules_type) {
      // "не выводить результат расчета"
      case 100_000_000: {
        sum = 0;
        numCalc = Number.parseInt(defaultRow.numCalc, 2);
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        break;
      }

      // "проверка на мин.тариф"
      case 100_000_001: {
        const newSum = round((sum / cost) * 100, 2);
        if (newSum < rule_evo_discount) {
          sum = 0;
          numCalc = Number.parseInt(defaultRow.numCalc, 2);
          skCalcId = defaultRow.skCalcId;
          if (selectedRule.evo_message) message = selectedRule.evo_message;
        }
        break;
      }

      // "скидка за счет КВ"
      case 100_000_002: {
        sum = (sum * (100 - rule_evo_discount)) / 100;
        numCalc = Number.parseInt(defaultRow.numCalc, 2);
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        break;
      }

      // "акционный тариф"
      case 100_000_003: {
        sum = (rule_evo_discount / 100) * cost;
        numCalc = Number.parseInt(defaultRow.numCalc, 2);
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        break;
      }
    }
  }

  if (sum > MAX_INSURANCE) {
    error ||= `Сумма по страховке превышает максимально допустимое значение по стоимости ОСАГО: ${Intl.NumberFormat(
      'ru',
      {
        currency: 'RUB',
        style: 'currency',
      }
    ).format(MAX_INSURANCE)}`;
  }
  if (sum < MIN_INSURANCE) {
    error ||= `Сумма по страховке не должна быть меньше допустимого значения по стоимости ОСАГО: ${Intl.NumberFormat(
      'ru',
      {
        currency: 'RUB',
        style: 'currency',
      }
    ).format(MIN_INSURANCE)}`;
  }

  return {
    ...row,
    insuranceCondition,
    message: error || message,
    numCalc: `${numCalc}`,
    skCalcId,
    status: error ? 'error' : null,
    sum,
  };
}

type ResponseOwnOsago = Awaited<ReturnType<typeof ownOsagoRequest>>;

export function convertOwnOsagoResult(result: ResponseOwnOsago | undefined, row: Row): Row {
  if (!result) {
    return {
      ...row,
      message:
        'Для получения расчета ОСАГО следует использовать калькулятор ЭЛТ или Индивидуальный запрос',
      numCalc: '',
      skCalcId: '',
      status: 'error',
      sum: 0,
      totalFranchise: 0,
    };
  }

  if (!result.evo_id) {
    return {
      ...row,
      message: 'Сервер не вернул идентификатор страховки evo_id',
      numCalc: '',
      skCalcId: '',
      status: 'error',
      sum: result.evo_graph_price_withoutnds || 0,
    };
  }

  return {
    ...row,
    message: null,
    numCalc: result.evo_id,
    status: null,
    sum: result.evo_graph_price_withoutnds || 0,
  };
}

type ConvertEltKaskoResponseInput = BaseConvertResponseInput & {
  response: ELT.ResponseEltKasko;
};

export async function convertEltKaskoResponse(input: ConvertEltKaskoResponseInput): Promise<Row> {
  const { context, response, row } = input;
  const { apolloClient, store } = context;

  const { kaskoSum = 0, paymentPeriods } = response;
  let { message, requestId, skCalcId, totalFranchise = 0, error } = response;

  const { $calculation } = store;
  const leasingPeriod = $calculation.element('tbxLeasingPeriod').getValue();
  let sum = leasingPeriod <= 16 ? kaskoSum : paymentPeriods?.[0]?.kaskoSum || 0;

  const {
    data: { account: insuranceCompany },
  } = await apolloClient.query({
    query: CRMTypes.GetInsuranceCompanyDocument,
    variables: { accountId: row.key },
  });

  if (
    insuranceCompany?.evo_kasko_fact_part !== null &&
    insuranceCompany?.evo_kasko_plan_part !== undefined &&
    insuranceCompany?.evo_kasko_plan_part !== null &&
    insuranceCompany?.evo_kasko_plan_part !== undefined &&
    insuranceCompany?.evo_kasko_fact_part > insuranceCompany?.evo_kasko_plan_part
  ) {
    requestId = defaultRow.requestId;
    skCalcId = defaultRow.skCalcId;
    sum = defaultRow.sum;
    totalFranchise = defaultRow.totalFranchise;
    error = 'Расчет возможен только через отдел страхования ЛК';
  }

  const cost =
    $calculation.$values.getValue('plPriceRub') -
    $calculation.$values.getValue('discountRub') -
    $calculation.$values.getValue('importProgramSum') +
    $calculation.$values.getValue('addEquipmentPrice');

  const selectedRule = await getInsuranceRule(input, { cost, riskType: 'kasko' });

  const insuranceCondition = selectedRule?.evo_id ?? null;

  if (selectedRule) {
    const rule_evo_discount = selectedRule.evo_discount ?? 0;

    switch (selectedRule.evo_rules_type) {
      // "не выводить результат расчета"
      case 100_000_000: {
        sum = 0;
        requestId = defaultRow.requestId;
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        totalFranchise = 0;
        break;
      }

      // "проверка на мин.тариф"
      case 100_000_001: {
        const newSum = round((sum / cost) * 100, 2);
        if (newSum < rule_evo_discount) {
          sum = 0;
          requestId = defaultRow.requestId;
          skCalcId = defaultRow.skCalcId;
          if (selectedRule.evo_message) message = selectedRule.evo_message;
          totalFranchise = 0;
        }
        break;
      }

      // "скидка за счет КВ"
      case 100_000_002: {
        sum = (sum * (100 - rule_evo_discount)) / 100;
        requestId = defaultRow.requestId;
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        totalFranchise = 0;
        break;
      }

      // "акционный тариф"
      case 100_000_003: {
        sum = (rule_evo_discount / 100) * cost;
        requestId = defaultRow.requestId;
        skCalcId = defaultRow.skCalcId;
        if (selectedRule.evo_message) message = selectedRule.evo_message;
        totalFranchise = 0;
        break;
      }
    }
  }

  if (totalFranchise > MAX_FRANCHISE) {
    error ||= `Франшиза по страховке превышает максимально допустимое значение: ${Intl.NumberFormat(
      'ru',
      {
        currency: 'RUB',
        style: 'currency',
      }
    ).format(MAX_FRANCHISE)}`;
  }

  if (sum > MAX_INSURANCE) {
    error ||= `Сумма по страховке превышает максимально допустимое значение по стоимости КАСКО: ${Intl.NumberFormat(
      'ru',
      {
        currency: 'RUB',
        style: 'currency',
      }
    ).format(MAX_INSURANCE)}`;
  }

  if (sum < MIN_INSURANCE) {
    error ||= `Сумма по страховке не должна быть меньше допустимого значения по стоимости КАСКО: ${Intl.NumberFormat(
      'ru',
      {
        currency: 'RUB',
        style: 'currency',
      }
    ).format(MIN_INSURANCE)}`;
  }

  return {
    ...row,
    insuranceCondition,
    message: error || message,
    numCalc: '0',
    requestId,
    skCalcId,
    status: error ? 'error' : null,
    sum,
    totalFranchise,
  };
}