EvoCalculator.Client2/apps/web/stores/tables/insurance/index.ts

import Validation from '../../validation';
import type { ValidationParams } from '../../validation/types';
import type * as Insurance from '@/Components/Calculation/Form/Insurance/InsuranceTable/types';
import * as insuranceTableConfig from '@/config/tables/insurance-table';
import type RootStore from '@/stores/root';
import { makeAutoObservable } from 'mobx';

export type InsuranceTableData = {
  options?: Record<Insurance.Keys, Insurance.RowOptions>;
  statuses?: Record<Insurance.Keys, Insurance.RowStatuses>;
  values?: Insurance.RowValues[];
};

export default class InsuranceTable {
  private root: RootStore;
  public validation: Validation;
  private values: Insurance.RowValues[] = insuranceTableConfig.defaultValues;
  private options: Record<Insurance.Keys, Insurance.RowOptions> =
    insuranceTableConfig.defaultOptions;
  private statuses: Record<Insurance.Keys, Insurance.RowStatuses> =
    insuranceTableConfig.defaultStatuses;

  constructor(rootStore: RootStore) {
    this.validation = new Validation(
      {
        err_key: 'ERR_INSURANCE_TABLE',
        err_title: 'Таблица страхования',
      },
      rootStore
    );

    makeAutoObservable(this);
    this.root = rootStore;
  }

  public get hasErrors() {
    return this.validation.hasErrors;
  }

  public hydrate = ({
    values: initialValues,
    options: initialOptions,
    statuses: initialStatuses,
  }: InsuranceTableData) => {
    if (initialValues) this.values = initialValues;
    if (initialOptions) this.options = initialOptions;
    if (initialStatuses) this.statuses = initialStatuses;
  };

  public setError = (params: ValidationParams) => this.validation.setError(params);

  public removeError = (params: Pick<ValidationParams, 'key'>) => {
    this.validation.removeError(params);
  };

  public reset = () => {
    this.values = insuranceTableConfig.defaultValues;
    this.options = insuranceTableConfig.defaultOptions;
    this.statuses = insuranceTableConfig.defaultStatuses;
    this.validation.clearErrors();
  };

  public row = <K extends Insurance.Keys>(key: K) => ({
    block: (valueName: Insurance.Values) => {
      this.statuses[key][valueName] = 'Disabled';

      return this.row(key);
    },

    column: <V extends Insurance.Values>(valueName: V) => ({
      block: () => {
        this.row(key).block(valueName);

        return this.row(key).column(valueName);
      },
      resetOptions: () => {
        this.row(key).resetOptions(valueName);

        return this.row(key).column(valueName);
      },
      resetValue: () => {
        this.row(key).resetValue(valueName);

        return this.row(key).column(valueName);
      },
      setOptions: (options: Insurance.RowOptions[V]) => {
        this.row(key).setOptions(valueName, options);

        return this.row(key).column(valueName);
      },
      setValue: (value: Insurance.RowValues[V]) => {
        this.row(key).setValue(valueName, value);

        return this.row(key).column(valueName);
      },
      unblock: () => {
        this.row(key).unblock(valueName);

        return this.row(key).column(valueName);
      },
    }),

    getOptions: <V extends Insurance.Values>(valueName: V) => this.options[key][valueName],

    getStatus: (valueName: Insurance.Values) => {
      if (this.root.$process.has('Unlimited')) return 'Default';

      return this.statuses[key][valueName];
    },

    getValue: <V extends Insurance.Values>(valueName: V) => {
      const rowIndex = this.values.findIndex((x) => x.key === key);

      return this.values[rowIndex][valueName];
    },

    getValues: () => {
      const rowIndex = this.values.findIndex((x) => x.key === key);

      return this.values[rowIndex];
    },

    reset: (valueName: Insurance.Values) => {
      this.row(key).resetValue(valueName).resetStatus(valueName).resetOptions(valueName);

      return this.row(key);
    },

    resetOptions: <V extends Insurance.Values>(valueName: V) => {
      this.options[key][valueName] = insuranceTableConfig.defaultOptions[key][valueName];

      return this.row(key);
    },

    resetStatus: (valueName: Insurance.Values) => {
      this.statuses[key][valueName] = insuranceTableConfig.defaultStatuses[key][valueName];

      return this.row(key);
    },

    resetValue: (valueName: Insurance.Values) => {
      const rowIndex = this.values.findIndex((x) => x.key === key);

      const defaultValue = insuranceTableConfig.defaultValues[rowIndex][valueName];
      this.values[rowIndex] = { ...this.values[rowIndex], [valueName]: defaultValue };

      return this.row(key);
    },

    setOptions: <V extends Insurance.Values>(valueName: V, options: Insurance.RowOptions[V]) => {
      this.options[key][valueName] = options;

      return this.row(key);
    },

    setValue: <V extends Insurance.Values>(valueName: V, value: Insurance.RowValues[V]) => {
      const rowIndex = this.values.findIndex((x) => x.key === key);

      this.values[rowIndex] = { ...this.values[rowIndex], [valueName]: value };

      return this.row(key);
    },

    setValues: (row: Insurance.RowValues) => {
      (Object.keys(row) as Insurance.Values[]).forEach((valueName) => {
        this.row(row.key).setValue(valueName, row[valueName]);
      });
    },

    unblock: (valueName: Insurance.Values) => {
      this.statuses[key][valueName] = 'Default';

      return this.row(key);
    },
  });
}