@cloud-ru/uikit-product-calculator 0.33.3

package/src/config/platforms/advanced/product-config/AdvancedObjectStorage.ts

@@ -0,0 +1,232 @@
+import { CONTROL, FormConfig, StepperControl } from '../../../../components';
+import { getObs, UnitsOfCalculationItem } from '../../../utils';
+
+const StorageClassItem = {
+  Cold: 'Cold',
+  Standard: 'Standard',
+  Warm: 'Warm',
+};
+
+const storageClassItems = [
+  {
+    value: StorageClassItem.Standard,
+    label: 'Горячее (Standard)',
+    description:
+      'Стандартный класс хранения обеспечивает высокий уровень доступа и применим как к большим массивам данных, к которым требуется частый доступ, так и к небольшим (менее 1 МБ) данным.',
+  },
+  {
+    value: StorageClassItem.Warm,
+    label: 'Теплое (Warm)',
+    description: 'Подходит для хранения информации, доступ к которой требуется нечасто (меньше 12-ти раз в год).',
+  },
+  {
+    value: StorageClassItem.Cold,
+    label: 'Холодное (Cold)',
+    description:
+      'Архивный класс хранения предназначен для данных, доступ к которым требуется редко (в среднем один раз в год).',
+  },
+];
+
+const DataRedundancyPolicyItem = {
+  Multi: 'Multi',
+  Single: 'Single',
+};
+
+const dataRedundancyPolicyItems = [
+  {
+    value: DataRedundancyPolicyItem.Multi,
+    label: 'В трех зонах',
+  },
+  {
+    value: DataRedundancyPolicyItem.Single,
+    label: 'В одной зоне',
+  },
+];
+
+const RestoringDataTypeItem = {
+  Standard:
+    // тут очепятка намеренная, тк бек такое тоже ждет
+    'Standart',
+  Fast: 'Fast',
+};
+
+const restoringDataTypeItems = [
+  {
+    value: RestoringDataTypeItem.Standard,
+    label: 'Стандартное',
+  },
+  {
+    value: RestoringDataTypeItem.Fast,
+    label: 'Быстрое',
+  },
+];
+
+const apiUiOptions: Partial<StepperControl['uiProps']> = {
+  min: 0,
+  step: 1_000,
+  max: 9_999_999_000,
+  showHint: false,
+  postfix: 'Шт',
+};
+
+export const OBJECT_STORAGE_FORM_CONFIG: FormConfig = {
+  ui: [
+    'storageClass',
+    ['storage', 'dataRedundancyPolicy'],
+    'apiActions',
+    ['internetOutbound'],
+    ['restoringDataType'],
+    ['quantityRestoringData'],
+  ],
+  controls: {
+    storageClass: {
+      type: CONTROL.Carousel,
+      defaultValue: StorageClassItem.Standard,
+      items: storageClassItems,
+      accessorKey: 'storages[0].obs.storageClass',
+      decoratorProps: {
+        label: 'Тип хранилища',
+      },
+    },
+    storage: getObs({
+      space: {
+        accessorKey: 'storages[0].obs.storage.space',
+        label: 'Размер хранилища',
+        defaultValue: 100,
+        uiProps: {
+          min: 0,
+          max: 9_999_999_900,
+          showHint: false,
+        },
+      },
+      units: {
+        accessorKey: 'storages[0].obs.storage.specification',
+      },
+    }),
+    dataRedundancyPolicy: {
+      type: CONTROL.Segmented,
+      accessorKey: 'storages[0].obs.dataRedundancyPolicy',
+      defaultValue: DataRedundancyPolicyItem.Single,
+      items: dataRedundancyPolicyItems,
+      decoratorProps: {
+        label: 'Зона доступности хранения данных',
+      },
+      watchedControls: { storageClass: 'storages[0].obs.storageClass' },
+      relateFn: ({ storageClass }) => {
+        if (storageClass === StorageClassItem.Cold) {
+          return {
+            items: dataRedundancyPolicyItems.slice(1),
+          };
+        }
+      },
+    },
+    apiActions: {
+      type: CONTROL.Object,
+      decoratorProps: {
+        label: 'Количество операций API',
+      },
+      ui: [['apiGet'], ['apiPut'], ['apiDelete']],
+      controls: {
+        apiGet: {
+          type: CONTROL.Stepper,
+          defaultValue: 0,
+          accessorKey: 'storages[0].obs.apiGet',
+          decoratorProps: {
+            label: 'GET-операции',
+          },
+          uiProps: apiUiOptions,
+        },
+        apiPut: {
+          type: CONTROL.Stepper,
+          defaultValue: 0,
+          accessorKey: 'storages[0].obs.apiPut',
+          decoratorProps: {
+            label: 'PUT-операции',
+          },
+          uiProps: apiUiOptions,
+        },
+        apiDelete: {
+          type: CONTROL.Stepper,
+          defaultValue: 0,
+          accessorKey: 'storages[0].obs.apiDelete',
+          decoratorProps: {
+            label: 'DELETE-операции',
+          },
+          uiProps: apiUiOptions,
+        },
+      },
+    },
+
+    internetOutbound: getObs({
+      space: {
+        accessorKey: 'storages[0].obs.internetOutbound.traffic',
+        label: 'Исходящий трафик в интернет',
+        defaultValue: 0,
+      },
+      units: {
+        accessorKey: 'storages[0].obs.internetOutbound.unitsOfCalculation',
+      },
+    }),
+    restoringDataType: {
+      type: CONTROL.Segmented,
+      accessorKey: 'storages[0].obs.restoringDataType',
+      defaultValue: RestoringDataTypeItem.Standard,
+      items: restoringDataTypeItems,
+      decoratorProps: {
+        label: 'Восстановление данных',
+      },
+      watchedControls: { storageClass: 'storages[0].obs.storageClass' },
+      relateFn: ({ storageClass }) => {
+        if (storageClass !== StorageClassItem.Cold) {
+          return {
+            uiProps: {
+              visible: false,
+            },
+          };
+        }
+      },
+    },
+    quantityRestoringData: getObs({
+      space: {
+        accessorKey: 'storages[0].obs.quantityRestoringData.quantity',
+        label: 'Объём восстановленных данных',
+        defaultValue: 0,
+        uiProps: {
+          max: 9_999_999_900,
+        },
+        watchedControls: {
+          storageClass: 'storages[0].obs.storageClass',
+          unitsOfCalculation: 'storages[0].obs.quantityRestoringData.unitsOfCalculation',
+        },
+        relateFn: ({ storageClass, unitsOfCalculation }) => {
+          const uiProps: Partial<StepperControl['uiProps']> = {};
+
+          if (unitsOfCalculation === UnitsOfCalculationItem.Tb) {
+            uiProps.max = 9_765_620;
+            uiProps.postfix = 'ТБ';
+          }
+
+          if (storageClass !== StorageClassItem.Cold) {
+            uiProps.visible = false;
+          }
+
+          return { uiProps };
+        },
+      },
+      units: {
+        accessorKey: 'storages[0].obs.quantityRestoringData.unitsOfCalculation',
+        watchedControls: { storageClass: 'storages[0].obs.storageClass' },
+
+        relateFn: ({ storageClass }) => {
+          if (storageClass !== StorageClassItem.Cold) {
+            return {
+              uiProps: {
+                visible: false,
+              },
+            };
+          }
+        },
+      },
+    }),
+  },
+};

package/src/config/platforms/advanced/product-config/AdvancedPostgreSqlDatabase.ts

@@ -0,0 +1,402 @@
+import { CONTROL, FormConfig, SegmentedControl, StepperControl } from '../../../../components';
+import { generateCpuItems, generateRamItems, getEip, getObs } from '../../../utils';
+import { getDisk } from '../../../utils/diskPostgreSqlMySQL';
+
+const BdInstanceTypeItem = {
+  Single: 'Single',
+  Replica: 'Replica',
+  PrimaryStandby: 'Primary/Standby',
+};
+
+const bdInstanceTypeItems = [
+  {
+    value: BdInstanceTypeItem.Single,
+    label: 'Single',
+    description: 'Одноузловая конфигурация',
+  },
+  {
+    value: BdInstanceTypeItem.PrimaryStandby,
+    label: 'Primary/Standby',
+    description: 'Отказоустойчивый кластер высокой доступности',
+  },
+];
+
+const BdEngineVersionItem = {
+  General_Purpose: 'General Purpose',
+  Dedicated: 'Dedicated',
+} as const;
+
+const bdEngineVersionItems = [
+  {
+    value: BdEngineVersionItem.Dedicated,
+    label: 'Dedicated',
+    description: `Инстансы имеют выделенные ресурсы процессора`,
+  },
+  {
+    value: BdEngineVersionItem.General_Purpose,
+    label: 'General Purpose',
+    description: `Инстансы используют ресурсы процессора совместно с другими инстансами того же класса, размещенными на одном физическом сервере`,
+  },
+];
+
+const CpuRamByClassType: {
+  [instanceClass: string]: { [instanceType: string]: Record<string, number[]> };
+} = {
+  [BdEngineVersionItem.Dedicated]: {
+    [BdInstanceTypeItem.Single]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+      '16': [64],
+      '32': [128],
+      '64': [256],
+    },
+    [BdInstanceTypeItem.PrimaryStandby]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+      '16': [64],
+      '32': [128],
+      '64': [256],
+    },
+    [BdInstanceTypeItem.Replica]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+      '16': [64],
+      '32': [128],
+      '64': [256],
+    },
+  },
+  [BdEngineVersionItem.General_Purpose]: {
+    [BdInstanceTypeItem.Single]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+    },
+    [BdInstanceTypeItem.PrimaryStandby]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+    },
+    [BdInstanceTypeItem.Replica]: {
+      '2': [4, 8],
+      '4': [8, 16],
+      '8': [16, 32],
+    },
+  },
+};
+
+type GetRdsControlsProps = {
+  prefix: string;
+};
+
+const getRdsControls = ({
+  prefix,
+}: GetRdsControlsProps): {
+  cpu: SegmentedControl;
+  ram: SegmentedControl;
+  bdQuantity: StepperControl;
+} => ({
+  cpu: {
+    type: CONTROL.Segmented,
+    accessorKey: `${prefix}.cpu`,
+    defaultValue: '2',
+    watchedControls: {
+      rdsBdEngineVersion: 'rds.bdInstanceClass',
+      rdsBdInstanceType: 'rds.bdInstanceType',
+    },
+    items: [],
+    decoratorProps: {
+      label: 'Количество vCPU',
+      labelTooltip: 'Виртуальный процессор',
+    },
+    relateFn: ({
+      rdsBdEngineVersion,
+      rdsBdInstanceType,
+    }: {
+      rdsBdEngineVersion: string;
+      rdsBdInstanceType: string;
+    }) => ({
+      items: generateCpuItems(
+        Object.entries(CpuRamByClassType[rdsBdEngineVersion][rdsBdInstanceType]).map(([key]) => Number(key)) ?? [],
+      ),
+    }),
+  },
+  ram: {
+    type: CONTROL.Segmented,
+    accessorKey: `${prefix}.ram`,
+    defaultValue: '4',
+    items: [],
+    decoratorProps: {
+      label: 'Объём RAM',
+      labelTooltip: 'Оперативная память',
+    },
+    watchedControls: {
+      cpu: `${prefix}.cpu`,
+      rdsBdEngineVersion: 'rds.bdInstanceClass',
+      rdsBdInstanceType: 'rds.bdInstanceType',
+    },
+    relateFn: ({
+      cpu,
+      rdsBdEngineVersion,
+      rdsBdInstanceType,
+    }: {
+      cpu: string;
+      rdsBdEngineVersion: string;
+      rdsBdInstanceType: string;
+    }) => ({
+      items: generateRamItems(CpuRamByClassType[rdsBdEngineVersion][rdsBdInstanceType][cpu] ?? []),
+    }),
+  },
+  bdQuantity: {
+    type: CONTROL.Stepper,
+    accessorKey: `${prefix}.bdQuantity`,
+    defaultValue: 1,
+    decoratorProps: {
+      label: 'Количество баз данных',
+    },
+    uiProps: {
+      min: 1,
+      max: 50,
+      postfix: 'Шт',
+    },
+  },
+});
+
+const rds = getRdsControls({ prefix: 'rds' });
+const bdReplicaRds = getRdsControls({ prefix: 'bdReplica.rds' });
+
+export const POSTGRE_SQL_DATA_BASE_FORM_CONFIG: FormConfig = {
+  ui: [
+    'rdsBdEngineVersion',
+    'rdsBdInstanceType',
+    'bdInstanceAlert',
+    ['rdsCpu', 'rdsRam'],
+    ['evs', 'rdsBdQuantity'],
+    'bdReplica',
+    'eip',
+    ['obs'],
+  ],
+  controls: {
+    rdsBdEngineVersion: {
+      type: CONTROL.Carousel,
+      accessorKey: 'rds.bdInstanceClass',
+      defaultValue: BdEngineVersionItem.Dedicated,
+      items: bdEngineVersionItems,
+      decoratorProps: {
+        label: 'Класс инстанса',
+      },
+    },
+    rdsBdInstanceType: {
+      type: CONTROL.Carousel,
+      accessorKey: 'rds.bdInstanceType',
+      items: bdInstanceTypeItems,
+      defaultValue: BdInstanceTypeItem.Single,
+      decoratorProps: {
+        label: 'Режим развертывания',
+      },
+    },
+    bdInstanceAlert: {
+      type: 'alert',
+      uiProps: {
+        appearance: 'info',
+        description:
+          'Данный режим подразумевает развертывание на двух инстансах — Primary и Standby. Конфигурация инстанса Primary дублируется для инстанса Standby. Стоимость в чеке указывается за 2 инстанса',
+        outline: true,
+        visible: false,
+      },
+      accessorKey: 'instances',
+      watchedControls: { bdInstanceType: 'rds.bdInstanceType' },
+      relateFn: ({ bdInstanceType }) => {
+        if (bdInstanceType === BdInstanceTypeItem.PrimaryStandby) {
+          return {
+            uiProps: {
+              visible: true,
+            },
+          };
+        }
+      },
+    },
+    bdReplica: {
+      type: CONTROL.Object,
+      ui: ['replica'],
+      visible: true,
+      controls: {
+        replica: {
+          type: CONTROL.ToggleObject,
+          switchKey: 'bdReplicaIsNeeded',
+          decoratorProps: {
+            label: 'Реплика базы данных',
+            labelTooltip: 'Тип сервера реплики равен типу сервера базы данных',
+          },
+          control: {
+            type: CONTROL.Object,
+            ui: [
+              ['cpu', 'ram'],
+              ['systemDisk', 'bdQuantity'],
+            ],
+            controls: {
+              cpu: {
+                ...bdReplicaRds.cpu,
+                decoratorProps: {
+                  ...bdReplicaRds.cpu.decoratorProps,
+                  labelTooltip: 'Количество vCPU реплики рекомендуется выбирать равное количеству основного RDS',
+                },
+              },
+              ram: {
+                ...bdReplicaRds.ram,
+                decoratorProps: {
+                  ...bdReplicaRds.ram.decoratorProps,
+                  labelTooltip: 'Объем RAM реплики рекомендуется выбирать равное количеству основного RDS',
+                },
+              },
+              bdQuantity: {
+                ...bdReplicaRds.bdQuantity,
+                accessorKey: 'bdReplica.replicaQuantity',
+                decoratorProps: {
+                  label: 'Количество реплик',
+                },
+                uiProps: {
+                  min: 1,
+                  max: 5,
+                  postfix: 'Шт',
+                },
+              },
+              systemDisk: getDisk({
+                space: {
+                  accessorKey: 'bdReplica.evs.systemDisk.diskSpace',
+                  defaultValue: 40,
+                  uiProps: {
+                    min: 40,
+                    max: 4000,
+                    disabled: true,
+                  },
+                  decoratorProps: {
+                    labelTooltip:
+                      'SSD имеют высокую скорость передачи данных, что в два раза быстрее, чем HDD-накопители',
+                  },
+                },
+                specification: {
+                  accessorKey: 'bdReplica.evs.systemDisk.specification',
+                  defaultValue: 'Cloud SSD',
+                  uiProps: { disabled: true },
+                },
+              }),
+
+              // Hidden
+              replicaQuantity: {
+                type: CONTROL.Stepper,
+                accessorKey: 'bdReplica.rds.bdQuantity',
+                defaultValue: 1,
+                decoratorProps: {
+                  label: '',
+                },
+                uiProps: {
+                  visible: false,
+                },
+              },
+
+              // Hidden
+              evsAdditionalDisks: {
+                type: 'select-multiple',
+                accessorKey: 'bdReplica.evs.additionalDisks',
+                items: [],
+                defaultValue: [],
+                uiProps: {
+                  visible: false,
+                },
+                decoratorProps: {
+                  label: '',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+
+    rdsCpu: {
+      ...rds.cpu,
+      onChangeFn: (value, setValue) => {
+        setValue([
+          ['rds.cpu', value],
+          ['bdReplica.rds.cpu', value],
+        ]);
+      },
+    },
+    rdsRam: {
+      ...rds.ram,
+      onChangeFn: (value, setValue) => {
+        setValue([
+          ['rds.ram', value],
+          ['bdReplica.rds.ram', value],
+        ]);
+      },
+    },
+    rdsBdQuantity: rds.bdQuantity,
+
+    evs: getDisk({
+      space: {
+        accessorKey: 'evs.systemDisk.diskSpace',
+        defaultValue: 40,
+        uiProps: {
+          min: 40,
+          max: 4000,
+        },
+        onChangeFn: (value, setValue) => {
+          setValue([
+            ['evs.systemDisk.diskSpace', value],
+            ['bdReplica.evs.systemDisk.diskSpace', value],
+          ]);
+        },
+      },
+      specification: {
+        accessorKey: 'evs.systemDisk.specification',
+        defaultValue: 'Cloud SSD',
+        onChangeFn: (value, setValue) => {
+          setValue([
+            ['evs.systemDisk.specification', value],
+            ['bdReplica.evs.systemDisk.specification', value],
+          ]);
+        },
+      },
+    }),
+    eip: getEip({
+      trafficKey: 'eip.traffic',
+    }),
+    obs: getObs({
+      space: {
+        accessorKey: 'obs.storage.space',
+        defaultValue: 0,
+      },
+      units: {
+        accessorKey: 'obs.storage.unitsOfCalculation',
+      },
+    }),
+
+    // Hidden
+    evsAdditionalDisks: {
+      type: 'select-multiple',
+      accessorKey: 'evs.additionalDisks',
+      items: [],
+      defaultValue: [],
+      uiProps: {
+        visible: false,
+      },
+      decoratorProps: {
+        label: '',
+      },
+    },
+    // Hidden
+    ipQuantity: {
+      accessorKey: 'eip.ipQuantity',
+      type: CONTROL.Stepper,
+      defaultValue: 0,
+      decoratorProps: {},
+      uiProps: {
+        visible: false,
+      },
+    },
+  },
+};