EvoCalculator.Client2/apps/web/process/supplier-agent/lib/create-reactions.ts

/* eslint-disable @typescript-eslint/naming-convention */
import type { ApolloClient } from '@apollo/client';
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc';
import * as CRMTypes from 'graphql/crm.types';
import { autorun, reaction } from 'mobx';
import type RootStore from 'stores/root';
import ValidationHelper from 'stores/validation/helper';
import { normalizeOptions } from 'tools/entity';
import { makeDisposable } from 'tools/mobx';
import type { AgentsFields, AgentsRewardConditionsFields, AgentsSumFields } from './types';

dayjs.extend(utc);

export function fillAgentRewardReaction(
  store: RootStore,
  apolloClient: ApolloClient<object>,
  agentParams: {
    agentField: AgentsFields;
    rewardConditionField: AgentsRewardConditionsFields;
  }
) {
  const { $calculation, $process } = store;
  const { agentField, rewardConditionField } = agentParams;

  reaction(
    () => $calculation.element(agentField).getValue(),
    async (agentid) => {
      if (!agentid) {
        $calculation.element(rewardConditionField).reset();

        return;
      }
      const {
        data: { evo_reward_conditions },
      } = await apolloClient.query({
        query: CRMTypes.GetRewardConditionsDocument,
        variables: {
          agentid,
          currentDate: dayjs().toISOString(),
        },
      });

      if (evo_reward_conditions?.length) {
        $calculation
          .element(rewardConditionField)
          .setOptions(normalizeOptions(evo_reward_conditions));
      } else {
        $calculation.element(rewardConditionField).reset();
      }
    }
  );
}

export function fillAgentRewardSummReaction(
  store: RootStore,
  apolloClient: ApolloClient<object>,
  agentParams: {
    rewardConditionField: AgentsRewardConditionsFields;
    rewardSummField: AgentsSumFields;
  }
) {
  const { $calculation, $process } = store;
  const { rewardConditionField, rewardSummField } = agentParams;

  makeDisposable(
    () =>
      reaction(
        () => $calculation.element(rewardConditionField).getValue(),
        async (rewardConditionId) => {
          if (!rewardConditionId) {
            $calculation.element(rewardSummField).reset();

            return;
          }

          const {
            data: { evo_reward_condition },
          } = await apolloClient.query({
            query: CRMTypes.GetRewardConditionDocument,
            variables: {
              conditionId: rewardConditionId,
            },
          });

          if (evo_reward_condition?.evo_reward_summ) {
            $calculation.element(rewardSummField).setValue(evo_reward_condition.evo_reward_summ);
          } else {
            $calculation.element(rewardSummField).resetValue();
          }
        }
      ),
    () => $process.has('LoadKP')
  );

  reaction(
    () => $calculation.element(rewardConditionField).getValue(),
    (rewardConditionId) => {
      if (rewardConditionId) {
        $calculation.element(rewardSummField).unblock();
      } else {
        $calculation.element(rewardSummField).block();
      }
    }
  );
}

export function validateAgentRewardSumm(
  store: RootStore,
  apolloClient: ApolloClient<object>,
  agentParams: {
    rewardConditionField: AgentsRewardConditionsFields;
    rewardSummField: AgentsSumFields;
  }
) {
  const { $calculation } = store;
  const { rewardConditionField, rewardSummField } = agentParams;

  const validationHelper = new ValidationHelper();

  reaction(
    () => $calculation.element(rewardSummField).getValue(),
    async (rewardSumm) => {
      const conditionId = $calculation.element(rewardConditionField).getValue();
      if (!conditionId) {
        validationHelper.removeErrors();

        return;
      }

      const {
        data: { evo_reward_condition },
      } = await apolloClient.query<
        CRMTypes.GetRewardConditionQuery,
        CRMTypes.GetRewardConditionQueryVariables
      >({
        query: CRMTypes.GetRewardConditionDocument,
        variables: {
          conditionId,
        },
      });

      if (!evo_reward_condition) {
        validationHelper.removeErrors();

        return;
      }

      if (evo_reward_condition.evo_reward_summ) {
        $calculation
          .element(rewardSummField)
          .validate({
            invalid: rewardSumm > evo_reward_condition?.evo_reward_summ,
            message: 'Вознаграждение указано больше условия по агентскому договору!',
          })
          .err((removeError) => {
            validationHelper.add(removeError);
          });
      }

      if (
        evo_reward_condition?.evo_reduce_reward !== null &&
        evo_reward_condition.evo_reward_summ
      ) {
        $calculation
          .element(rewardSummField)
          .validate({
            invalid:
              evo_reward_condition.evo_reduce_reward === false &&
              rewardSumm < evo_reward_condition.evo_reward_summ,
            message: 'Вознаграждение указано меньше условия по агентскому договору!',
          })
          .err((removeError) => {
            validationHelper.add(removeError);
          });
      }

      if (evo_reward_condition?.evo_min_reward_summ !== null) {
        $calculation
          .element(rewardSummField)
          .validate({
            invalid: rewardSumm < evo_reward_condition?.evo_min_reward_summ,
            message: 'Вознаграждение указано меньше условия по агентскому договору!',
          })
          .err((removeError) => {
            validationHelper.add(removeError);
          });
      }
    }
  );

  autorun(() => {
    const rewardSumm = $calculation.element(rewardSummField).getValue();
    const rewardConditionOptions = $calculation.$options.getOptions(rewardConditionField);

    const conditionIds = rewardConditionOptions.map((x) => x.value);
    const requests = conditionIds.map(async (conditionId) => {
      const {
        data: { evo_reward_condition },
      } = await apolloClient.query<
        CRMTypes.GetRewardConditionQuery,
        CRMTypes.GetRewardConditionQueryVariables
      >({
        query: CRMTypes.GetRewardConditionDocument,
        variables: {
          conditionId,
        },
      });

      return evo_reward_condition;
    });

    Promise.all(requests).then((results) => {
      const required_reward = results.some(
        (x) => x?.evo_agency_agreementidData?.evo_required_reward === true
      );
      $calculation.element(rewardSummField).validate({
        invalid: rewardSumm === 0 && required_reward,
        message: 'Согласно агентскому договору обязательна выплата АВ. Заложите АВ в расчет',
      });
    });
  });
}