Estimate/EstTypes.pas - master - YakuninAV/Convertors

Estimate/EstTypes.pas
3 597 строк175 KB
YakuninAV
empty coef
06 авг 2026, 14:24
06 авг 2026, 14:2496c1d4d
{*******************************************************}
{                                                       }
{       Estimates Import & Export                       }
{                                                       }
{       Copyright (C) 2020 Data Basis Development       }
{                                                       }
{*******************************************************}
/// Модуль содержит объявления типов используемых для работы со сметами
unit EstTypes;

{$I mormot.defines.inc}

interface

uses
{$IFDEF ISDELPHIXE2}
  System.SysUtils, System.Classes,
{$ELSE}
  SysUtils, Classes,
{$ENDIF}
  mormot.core.base, mormot.core.variants, mormot.core.unicode, mormot.core.data, mormot.core.os, mormot.core.text,
  mormot.core.buffers,
  DBDCommons, DBDStrUtils,
{$IFDEF FPC} EstRusStringsU {$ELSE} EstRusStringsA{$ENDIF}
 ;
const

  svNDS = 'НДС, %';
  svNR84 = 'Накладные расходы на строительные работы, НР84';
  svPN84 = 'Плановые накопления на строительные работы, ПН84';
  svNRFOT84 = 'Накладные расходы на монтажные работы, НРФОТ84';
  svPNFOT84 = 'Плановые накопления на монтажные работы, ПНФОТ84';
  svTZR = 'ТЗР, %';

  /// имя ресурса, содержащего список ценовых зон РЖД
  RES_RZD_ZONES: string = 'RZD_ZONES_UTF8';
  /// имя ресурса, содержащего список регионов РФ
  RES_RF_REGIONS: string = 'RF_REGIONS';

  EST_DOUBLE_PRECISION = 15;
/////////////////////////////////////// убрать из данного модуля
  META_SOFT_NAME = 'Программный комплекс "Строительный эксперт" ';//'ПК "Строительный эксперт", приложение "Турбо сметчик".';//'Data Basis Development. Экспортер в XML';
  META_SOFT_VERSION = '7.1.4';
  /// Версия данных
  META_DATA_VERSION = '1.09';
  DefaultMANVersionGGE = 40200;
  DefaultLOVVersionGGE = 30100;
  DefaultBIMVersionGGE = 30100;
  DefaultRIMVersionGGE = 30100;
  DefaultOECVersionGGE = 30100;
  DefaultSECVersionGGE = 30100;
  DefaultTSNVersionMGE = 10900;

  /// Билд программы BExpert начиная с которого выполняется экспорт по схеме ГГЕ 3.01
  BEEXERT_OLD_SCHEME_BUILD = 7718;
  /// Местоположение схемы представления смет
  //SCHEMA_FILE_NAME: TFileName = 'd:\databasis\data\gge\LocalEstimateBaseIndexMethod-1_08.8.xsd';
  SCHEMA_FILE_NAME: TFileName = 'G:\databasis\data\gge\LocalEstimateBaseIndexMethod-1_09.xsd';
  STYLESHEET_FILE_NAME: TFileName = 'G:\databasis\data\gge\LocalEstimate.xsl';
  TEMPLATE_BIM557_FILE_NAME='Шаблон 557пр базисно-индексный.etw';
  TEMPLATE_BIMPOS_FILE_NAME='Шаблон 557пр попозиционная индексация.etw';
  TEMPLATE_RIM557_FILE_NAME='Шаблон 557пр ресурсно-индексный.etw';
  TEMPLATE_TIM557_FILE_NAME='Шаблон 557пр TIMML.etw';
  TEMPLATE_MGETSN_FILE_NAME='Локальная ТСН-2001 XML.etw';
///////////////////////////////////////

var
  /// имя элемента, содержащего папку вывода файлов экспорта
  DestFolderJName: RawUtf8;
  /// имя элемента, содержащего опцию отмены вывода внедренных смет (для ОЕС и SEC при экспорте в двух уровнях цен)
  FlagNoEstExportJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг создания папки
  FlagFolderJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг сохранения исходного расширения файла
  FlagSaveSrcExtJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг сохранения в папке внедрённых файлов
  FlagEmbededJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг запуска пропуска пустых разделов
//  FlagSkipEmptySectionsJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг запуска проверки полученного ГГЕ-файла на сайте
  FlagCheckResultJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг запуска просмотра HTML-документа со сметой
  FlagShowResultJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий формирование файла результата с расширением
  // ".xml" вместо ".gge"
  FlagExtentionIsXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг игнорирования формулы объёма
  FlagQtyFormulaXMLJName: RawUtf8;
  /// Флаг обработки пустых ссылок на документы
  FlagEmptyLinksIgnoreJName: RawUtf8;
  /// Флаг обработки пустых разделов (для Ведомости Объёмов Работ)
//  FlagEmptySectionIgnoreJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий игнорировать расценки выключенные в исходной смете
  FlagIgnoreZerosfXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий игнорировать подчинённые ресурсы выключенные в исходной смете
  FlagIgnoreSubZerosfXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий пропускать пустые секции (Total=0)
  FlagSkipEmptySectionJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий выводить в ГГЕ нулевые суммы с стоимости позиций
  FlagZeroPriceWriteJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий формирование ГГЕ в базисных ценах
  FlagPriceLevelBaseXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий импорт только итогов сметы
  FlagTotalsOnlyXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий установить флаг "Расчёт итогов в текущем уровне цен от итогов в базисном"
  FlagCalcFromCurrXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг предписывающий установить флаг "Расчёт ресурсов от текущей"
  FlagResFromCurrXMLJName: RawUtf8;
  /// Имя элемента JSON, содержащего название файла, содержащего схему XML-файла для представления сметы
  SchemaJName: RawUTF8;
  /// Имя элемента JSON, содержащего название файла-шаблона для формирования сметы в формате Турбосметчика
  TmpltJName: RawUTF8;
  /// Имя элемента JSON, содержащего название папки, содержащей справочники Турбосметчика
  BooksJName: RawUTF8;
  /// Имя элемента JSON, содержащего название файла, содержащего справочник нормативов накладных расходов
  OverdraftJName: RawUTF8;
  /// Имя элемента JSON, содержащего название файла, содержащего справочник нормативов сметной прибыли
  ProfitJName: RawUTF8;
  /// Имя элемента JSON, содержащего флаг для формирования JSON-файла с информацией о смете
  flagEdjJName: RawUTF8;
  /// Имя элемента JSON, содержащего флаг для обработки итогов
  NoTotalsJName: RawUTF8;
  /// Имя элемента JSON, содержащего идентификатор приказа
  OrderIdJName: RawUtf8;
  /// Сохранять номера подчиненных позиций при формировании XML
  UseSubNumJName: RawUtf8;
  /// Сохранять номера позиций при формировании XML
  UsePosNumJName: RawUtf8;
  /// Сохранять номера позиций для дополнительных трансротных расходов при формировании XML
  UsePortageNumJName: RawUtf8;
  // Идентификатор уровня цен составления сводного сметного расчёта
  PriceLevelIdJName: RawUtf8;
  /// Вычислить итоги сметы / раздела сметы
  CalcTotalsJName: RawUtf8;
  /// Состав выводимой информации по ССР
  SumConsistJName: RawUtf8;
  /// Подготовить данные для сводки затрат
  CostsSummaryJName: RawUtf8;
  /// Переключатель формирования сводки затрат/сводной сметы
  CSOutputSwitchJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для объектной сметы
  OECEstSchemaVerJName: RawUTF8;
  /// Имя элемента JSON, содержащего версию схемы для сводной сметы
  SECEstSchemaVerJName: RawUTF8;
  LocEstSchemaJName: RawUtf8;
  ObjEstSchemaJName: RawUtf8;
  SumEstSchemaJName: RawUtf8;
  RIMEstSchemaVerJName: RawUtf8;
  /// Имя элемента JSON, содержащего тип документа (сметы)
  DocTypeJName: RawUtf8;
  /// Имя элемента JSON, содержащего метод расчета локальных смет
  MethodJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для локальных смет
  LECVersionJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для локальных смет
  BIMVersionJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для локальных смет
  RIMVersionJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для объектных смет
  OECVersionJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для сводных смет
  SECVersionJName: RawUtf8;
  /// Имя элемента JSON, содержащего версию схемы для конъюктурного анализа
  MANVersionJName: RawUtf8;
  MANFlagFormulaInNameJName: RawUtf8;
  LOVVersionJName: RawUtf8;
  FlagEmptyFormulasJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг для размещения формулы объёма в наименовании позиции
  QtyFormulaJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг для размещения формулы оцены в наименовании позиции
  PrcFormulaJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг формирования для сводных смет в базисных ценах
  CSBasePricesEnabledJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг разрешающий добавление НДС в таблицу 2
  CSVATIntoTableJName: RawUtf8;
  /// Имя элемента JSON, содержащего флаг определяющий простое округление после деноминации суммы для сводки затрат
  CSDummyRoundJName: RawUtf8;
  CSEstimatesOnlyJName: RawUtf8;
  ///
  DestinationSchemaJName: RawUtf8;
  ///
  DestFileJName: RawUtf8;
  /// Флаг экспорта для МГЕ
  MGEDestFlagJName: RawUtf8;
  /// для сводных МИП формула записывается в наименование
  FlagFormulaInNameJName: RawUtf8;
const

  PrintPosWithNullVolumesID = 'PRINTPOS_WNULLVOLUMES'; //печатать позиции с нулевым объемом - для использования в драйвере печатной формы
  PrintNumWithNullVolumesID = 'PRINTNUM_WNULLVOLUMES'; //нумеровать позиции с нулевым объемом - параметр документа


type

  /// Разрабочики программ
  // adGsfx - GrandSmeta - gsfx(XML) файлы собственного изготовления
  TAppDeveloper = (adDatabasis, adABC, adGrand, adGsfx, adWinRik, adSmetaRu, adUndefine);
  TAppDevelopers = set of TAppDeveloper;

  TXmlEstimateType=(xetGGE, xetMGE, xetUndefined);

  /// тип значения используемый для представления сумм в сметах
  //  TEstimatesPrice = Double;
  //  TEstimatesPriceDynArray = array of TEstimatesPrice;

  /// Типы смет
  // etLEC - локальная смета
  // etOEC - объектная смета
  // etSEC - сводная смета
  // etMA  - конъюктурный анализ
  // etLOV - Ведомость объёмов
  // etEN  - Пояснительная записка
  TEstimateType = (etLEC, etBIM, etRIM, etRM, etTSN, etTIM, etSN2012, etOEC, etSEC, etMA, etCS, etLOV, etEN, etNone);

  /// Типы операций
  // eopSum - сложить
  // eopSub - вычесть
  // eopMul - умножить
  // eopDiv - разделить
  // eopSumFrac - сложить дробные
  TEstimateOperationType = (eopMul, eopDiv, eopSum, eopSub, eopSumFrac, eopNull);

  /// Типы элементов сметной стоимости
  // epiPrice              - Сметная стоимость
  // epiDirect             - Прямые затраты
  // epiTotalPrice         - Всего
  // epiTotalWithSubs      - Всего с учётом подчиненных позиций
  // epiWorkersSalary      - Оплата труда рабочих не занятых обслуживанием машин
  // epiMachinistSalary    - Оплата труда машинистов
  // epiSalary             - ФОТ = epiWorkersSalary+epiMachinistSalary
  // epiMachines           - Машины и механизмы в составе сметной стоимости
  // epiMaterials          - Материалы, изделия и конструкции в составе сметной стоимости
  // epiConstruction       - Сметная стоимость строительных работ
  // epiInstallation       - Сметная стоимость монтажных работ
  // epiRestoration        - Сметная стоимость реставрационных работ
  // epiRestoirarion1984   - Сметная стоимость реставрационных работ в ценах 1984
  // epiRestoirarion2001   - Сметная стоимость реставрационных работ в ценах 2001
  // epiRepair             - Сметная стоимость ремонтно-строительных работ
  // epiStartup            - Сметная стоимость пуско-наладочных работ
  // epiStartupOnIdle      - Сметная стоимость пуско-наладочных работ "в холостую"
  // epiStartupOnLoad      - Сметная стоимость пуско-наладочных работ "под нагрузкой"
  // epiEquipment          - Сметная стоимость оборудования, мебели, инвентаря
  // epiEquipmentNotENB    - Сметная стоимость оборудования, мебели, инвентаря, отсутствующего в СНБ
  // epiMaterialNotENB     - Материалы, изделия и конструкции в составе сметной стоимости, отсутствующие в СНБ
  // epiPortage            - Расходы на перевозку
  // epiLoading            - Расходы на погрузку
  // epiPortageCnstr       - Расходы на перевозку при выполнении строительных работ
  // epiPortageInstl       - Расходы на перевозку при выполнении монтажных работ
  // epiPortageMaterials   - Расходы на перевозку материалов
  // epiPortageEqmnt       - Расходы на перевозку оборудования
  // epiPortageTotal       -
  // epiPortageAdd         -
  // epiPortageCnstrAdd    - Доп.расходы на перевозку при выполнении строительных работ
  // epiPortageInstlAdd    - Доп.расходы на перевозку при выполнении монтажных работ
  // epiWarehouse          - Заготовительно-складские расходы
  // epiOther              - Сметная стоимость прочих затрат
  // epiOverhead           - Накладные расходы в составе сметной стоимости
  // epiProfit             - Сметная прибыль в составе сметной стоимости
  // epiOPWorkSalary       - Накладные и прибыль от зарплаты рабочих не занятых обслуживанием машин
  // epiOPMachSalary       - Накладные и прибыль от зарплаты машинистов
  // epiOverheadWorkSalary - Накладные расходы от зарплаты рабочих не занятых обслуживанием машин
  // epiOverheadMachSalary - Накладные расходы от зарплаты машинистов от зарплаты машинистов
  // epiProfitWorkSalary   - Сметная прибыль от зарплаты рабочих не занятых обслуживанием машин
  // epiProfitMachSalary   - Сметная прибыль от зарплаты машинистов
  // epiReturn             - Возврат
  // epiVAT                - Налог на добавленную стоимость
  // epiWinter             - Затраты на расходы в зимнее время
  // epiTemporary          - Затраты на временные здания и сооружения
  // epiLaborWorker        - Затраты труда основных рабочих
  // epiLaborMachinist     - Затраты труда механиков и машинистов
  // epiLabor              - Затраты труда забочих и машинистов
  // epiSummary            -
  // epiEquipmentMass      - Масса оборудования
  // epiDirtMass           - Масса вывозимого  грунта
  // epiDebrisMass         - Масса мусора
  // epiTotalLecHdr        - Итоговое значение для шапки локальной сметы (МГЕ)
  // epiEquLecHdr          - Итоговое значение оборудования для шапки локальной сметы (МГЕ)
  // epiPerPos             - ставка для позиции в сводных МИП
  // epiUndefine           - Неопределено
  TEstimatePriceItemType = (epiPrice, epiTotalPrice, epiTotalWithSubs,
                            epiWorkersSalary, epiMachinistSalary, epiMachinistSalaryExtra, epiSalary,
                            epiMachines, epiMachinesTotal,
                            epiMaterial, epiMaterialTotal, epiMaterialNotENB,
                            epiDirect, epiDirectNotOther,
                            epiConstruction, epiConstructionTotal, epiInstallation, epiInstallationTotal,
                            epiRestoration, epiRestoration1984, epiRestoration2001, epiRepair,
                            epiStartup, epiStartupSalary, epiStartupOnIdle, epiStartupOnLoad,
                            epiEquipment, epiEquipmentTotal, epiEquipmentNotENB,
                            epiPortage, epiPortageCnstr, epiPortageCnstrAdd, epiPortageInstl, epiPortageInstlAdd,
                            epiPortageMaterial, epiPortageEqmnt, epiPortageTotal, epiPortageAdd, epiLoading,
                            epiWarehouse,
                            epiOther, epiOtherWorks, epiOtherExpenses, epiOtherTotal, epiOtherPortage,
                            epiOverhead, epiOverheadWorkSalary, epiOverheadMachSalary,
                            epiProfit, epiProfitWorkSalary, epiProfitMachSalary,
                            epiOPWorkSalary, epiOPMachSalary,
                            epiReturn, epiVAT, epiWinter, epiTemporary, epiDebris, epiDirt, epiResource,
                            epiLaborWorker, epiLaborMachinist, epiLabor,
                            epiSummary, epiVolume,
                            epiEquipmentMass, epiDirtMass, epiDebrisMass,
                            epiTotalLecHdr, epiEquLecHdr,
                            epiPerPos,
                            epiUndefine);
  /// Набор типов элементов стоимости
  TEstimatePriceItemTypes = set of TEstimatePriceItemType;

  /// Массив элементов сметной стоимости
  TEstimatePriceItems = array[epiPrice..epiUndefine] of Double;

  /// Элемент сметной стоимости
  TPriceItemValue = packed record
    Price: Currency;
    Kind: TEstimatePriceItemType;
  end;

  /// Массив элементов сметной стоимости
  TPriceItemValueDynArray = array of TPriceItemValue;

  /// Массив строк для элементов сметной стоимости
  TEstimatePriceItemsStrings = array[epiPrice..epiUndefine] of string;

const
  EstPriceItemTypesAll: TEstimatePriceItemTypes = [epiPrice..epiUndefine];

  /// Набор всех допустимых типов элементов стоимости
  EstValidPriceItemTypes: TEstimatePriceItemTypes = [
                            epiPrice, epiDirect, epiTotalPrice, epiTotalWithSubs,
                            epiWorkersSalary, epiMachinistSalary, epiSalary, epiMachinistSalaryExtra, epiMachines, epiMaterial,
                            epiConstruction, epiInstallation, epiRestoration, epiRepair, epiStartup, epiEquipment,
                            epiPortage, epiWarehouse, epiOther,
                            epiOverhead, epiOverheadWorkSalary, epiOverheadMachSalary,
                            epiProfit, epiProfitWorkSalary, epiProfitMachSalary,
                            epiOPWorkSalary, epiOPMachSalary,
                            epiReturn, epiVAT, epiWinter,
                            epiLaborWorker, epiLaborMachinist, epiLabor
                                                    ];
   /// Набор всех допустимых типов элементов стоимости позиции
   EstPositionPriceItemTypes: TEstimatePriceItemTypes = [
                            epiPrice, epiDirect, epiTotalPrice, epiTotalWithSubs,
                            epiWorkersSalary, epiMachinistSalary, epiSalary, epiMachines, epiMaterial,
                            epiConstruction, epiInstallation, epiRestoration, epiRepair, epiStartup, epiEquipment,
                            epiPortage, epiWarehouse, epiOther,
                            epiOverhead, epiOverheadWorkSalary, epiOverheadMachSalary,
                            epiProfit, epiProfitWorkSalary, epiProfitMachSalary,
                            epiOPWorkSalary, epiOPMachSalary,
                            epiReturn, epiVAT, epiWinter,
                            epiLaborWorker, epiLaborMachinist, epiLabor
                                                        ];
   /// Набор всех допустимых типов элементов стоимости сметы
   EstEstimatePriceItemTypes: TEstimatePriceItemTypes = [
                            epiPrice, epiDirect,
                            epiWorkersSalary, epiMachinistSalary, epiMachinistSalaryExtra, epiSalary,
                            epiOverhead, epiProfit, epiMachines, epiMaterial,
                            epiOverheadWorkSalary, epiOverheadMachSalary, epiProfitWorkSalary, epiProfitMachSalary,
                            epiConstruction, epiInstallation, epiRestoration, epiEquipment,
                            epiOPWorkSalary, epiOPMachSalary,
                            epiTotalPrice,
                            epiLaborWorker, epiLaborMachinist,
                            epiPortage, epiWarehouse, epiReturn, epiVAT,
                            epiStartup, epiStartupSalary, epiStartupOnIdle, epiStartupOnLoad,
                            epiWinter, epiOther
                                                        ];
   /// Набор всех допустимых типов элементов стоимости раздела
   EstChapterPriceItemTypes: TEstimatePriceItemTypes = [
                            epiPrice, epiDirect,
                            epiWorkersSalary, epiMachinistSalary, epiMachinistSalaryExtra, epiSalary,
                            epiOverhead, epiProfit,
                            epiOverheadWorkSalary, epiOverheadMachSalary, epiProfitWorkSalary, epiProfitMachSalary,
                            epiMachines, epiMaterial,
                            epiConstruction, epiInstallation, epiRestoration, epiEquipment, epiOPWorkSalary, epiOPMachSalary,
                            epiTotalPrice,
                            epiLaborWorker, epiLaborMachinist, epiLabor,
                            epiPortage, epiWarehouse, epiReturn, epiVAT,
                            epiOther
                                                       ];
   /// Набор типов элементов стоимости, соответствующий графе Строительство
   EstConstructionPriceItems=[epiConstruction, epiConstructionTotal, epiRepair, epiRestoration];
   /// Набор типов элементов стоимости, соответствующий графе Монтаж
   EstInstallationPriceItems=[epiInstallation, epiInstallationTotal];
   /// Набор типов элементов стоимости, соответствующий графе Оборудование
   EstEquipmentPriceItems=[epiEquipment, epiEquipmentTotal, epiEquipmentNotENB];
   /// Набор типов элементов стоимости, соответствующий графе Прочие
   EstOtherPriceItems=[epiOther, epiPortage, epiStartup];
   /// Набор типов элементов стоимости, являющихся трудозатратами
   EstLabourPriceItems=[epiLaborWorker, epiLaborMachinist, epiLabor];
   /// Набор типов элементов стоимости на перевозку
   EstPortagePriceItems=[epiPortage, epiLoading, epiPortageAdd, epiPortageTotal, epiPortageCnstr, epiPortageCnstrAdd,
                         epiPortageInstl, epiPortageInstlAdd,
                         epiPortageEqmnt, epiPortageMaterial];
type

  /// Тип нормативов из федерального реестра сметных нормативов
  // entGSN - ГСН Гослударственные сметные нормативы
  // entOSN - ОСН Отраслевые сметные нормативы
  // entTER - ТЕР Территориальные сметные нормативы
  // entISN - ИСН Индивидуальные сметные нормативы
  // entOther -
  // entRef - справочная информация
  // entSplit  - Сплит-форма
  // entNZ  - НЗ ?????
  // entUndefine - неопределено
  TEstimateNormativeType = (entGSN, entOSN, entTER, entISN, entOther, entRef, entSplit, entNZ, entUndefine);
  TEstimateNormativeTypes = set of TEstimateNormativeType;

  /// Категории нормативов
  TEstimateNormativeKind = (enkMain,enkMetodology,enkOverheds, enkProfits, enkIndexes, enkOthers, enkUndefine);
  TEstimateNormativeKinds = set of TEstimateNormativeKind;

const
  EstValidEstimateNormativeTypes: TEstimateNormativeTypes = [entGSN, entOSN, entTER, entISN];

type

  /// Тип сметно-нормативной базы
  TEstimateNormativeBase = (enbFER, enbTER, enbRZD, enbTSN, enbGESN, enbOther);
  /// Набор типов сметно-нормативных баз
  TEstimateNormativeBases = set of TEstimateNormativeBase;
  /// Массив наименований типов сметно-нормативных баз
  TEstimateNormativeBaseNames = array[enbFER..enbOther] of string;
  /// Массив наименований типов сметно-нормативных баз
  TEstimateNormativeBaseNamesUTF8 = array[enbFER..enbOther] of RawUTF8;

  /// Методика расчета стоимости смет и нормативная база расценок и цен
  // ! ebmMP   - 1984 1984 г.    СССР
  // ! ebmMSC  - 1998 МТСН 81-98 Мосстройцены
  // ! ebmGSN  - 2000 ГЭСН 2001  Госстрой
  // ! ebmFER  - 2000 ФЕР 2001   Госстрой
  // ! ebmTSN  - 2000 ТСН-2001   Мосстройцены
  // ! ebmPIR  - 2001 ПИР        ПИР
  // ! ebmObj  - объектные сметы
  // ! ebmSum  - сводные сметы
  // ! ebmMan  - конъюктурный анализ
  // ! ebmLov  - Ведомость объёмов
  /// Набор методик расчета стоимости смет и нормативная база расценок и цен
  TEstimateBaseMethodic = (ebmMP, ebmMSC, ebmGSN, ebmFER, ebmTSN, ebmPIR, ebmObj, ebmSum, ebmMan, ebmLov, ebmDummy);
  /// Массив обозначений методик расчета стоимости смет и нормативная база расценок и цен
  TEstimateBaseMethodicNames = array[ebmMP..ebmDummy] of string;
  /// Массив обозначений методик расчета стоимости смет и нормативная база расценок и цен
  TEstimateBaseMethodicNamesUTF8 = array[ebmMP..ebmDummy] of RawUTF8;

  /// Типы нормативных баз с ценами и расценками
  // ! ebcConstruction    (Е) расценки на строительные и специальные строительные работы   (ФЕР, ТЕР, ГЭСН, ТСН, ОЕРЖ)
  // ! ebcRepair          (Р)расценки на ремонтно-строительные работы
  // ! ebcStartingUp      (П)расценки на пусконаладочные работы
  // ! ebcInstallation    (М) расценки на монтаж оборудования
  // ! ebcReconstruction  (МР)расценки на капитальный ремонт оборудования
  // ! ebcRebuilding      (КР)расценки на капитальный ремонт объектов железнодорожного транспорта
  // ! ebcEquipment       цены на оборудование
  // ! ebcMaterials       цены на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  // ! ebcPortage         расценки на эксплуатацию строительных машин и автотранспортных средств
  // ! ebcDummy           не задано
  TEstimateNormBaseCategory = (ebcConstruction, ebcInstallation, ebcRepair, ebcReconstruction, ebcRebuilding,
                               ebcStartingUp, ebcEquipment, ebcMaterials, ebcPortage, ebcDummy);
  /// Набор типов нормативных баз с ценами и расценками
  TEstimateNormBaseCategories = set of TEstimateNormBaseCategory;

  /// Типы цен
  // freezed - подежит замене на TEstimateCostType
  // epkNorm    - нормативная стоимость из справочника в базисных ценах
  // epkOneBase - стоимость единицы в базисных ценах с учётом поправок
  // epkOneCurr - стоимость единицы в текущих ценах с учётом поправок
  // epkOneIndx - стоимость единицы в текущих ценах без учёта поправок
  // epkVolume  - стоимость объёма в базисных ценах без учёта поправок
  // epkVolBase - стоимость объёма в базисных ценах с учётом поправок
  // epkVolCurr - стоимость объёма в текущих ценах с учётом поправок
  // epkVolIndx - стоимость объёма в текущих ценах без учёта поправок
  // epkTotBase - полная стоимость расценки в базисных ценах
  // epkTotCurr - полная стоимость расценки в текущих ценах
  // epkEstBase - полная стоимость сметы в базисных ценах
  // epkEstCurr - полная стоимость сметы в текущих ценах
  TEstimatePriceKind = (epkNorm, epkOneBase, epkOneCurr, epkOneIndx, epkVolume, epkVolBase, epkVolCurr, epkVolIndx,
                        epkTotBase, epkTotCurr, epkEstBase, epkEstCurr);
  TEstimatePriceKinds = set of TEstimatePriceKind;

  /// Типы цен используемых при составлении смет
  // ectNorm    - нормативная стоимость из справочника в базисных ценах
  // ectOneBase - стоимость единицы в базисных ценах с учётом поправок
  // ectOneCurr - стоимость единицы в текущих ценах с учётом поправок
  // ectOneIndx - стоимость единицы в текущих ценах без учёта поправок
  // ectVolume  - стоимость объёма в базисных ценах без учёта поправок
  // ectVolBase - стоимость объёма в базисных ценах с учётом поправок
  // ectVolCurr - стоимость объёма в текущих ценах с учётом поправок
  // ectVolIndx - стоимость объёма в текущих ценах без учёта поправок
  // ectBase    - стоимость в базисных ценах
  // ectCurr    - стоимость в текущих ценах
  // ectTotBase - полная стоимость расценки в базисных ценах
  // ectTotCurr - полная стоимость расценки в текущих ценах
  // ectEstBase - полная стоимость сметы в базисных ценах
  // ectEstCurr - полная стоимость сметы в текущих ценах
  // ectChpBase - полная стоимость раздела сметы в базисных ценах
  // ectChpCurr - полная стоимость раздела сметы в текущих ценах
  // ectDummy   - пустая стоимость
  TEstimateCostType = (ectNorm, ectBase, ectCurr,
                       ectOneBase, ectOneCurr, ectOneIndx, ectVolume, ectVolBase, ectVolCurr, ectVolIndx,
                       ectTotBase, ectTotCurr, ectChpBase, ectChpCurr, ectDummy);
  /// Набор типов цен, используемых при составлении смет
  TEstimateCostTypes = set of TEstimateCostType;

const
  /// Валидные типы цен, используемые при составлении смет
  EstValidCostTypes: TEstimateCostTypes = [ectNorm, ectBase, ectCurr, ectOneBase, ectOneCurr, ectOneIndx,
                                           ectVolume, ectVolBase, ectVolCurr, ectVolIndx,
                                           ectTotBase, ectTotCurr, ectChpBase, ectChpCurr];
  /// Типы цен, используемые в позициях смет
  EstPosCostTypes: TEstimateCostTypes = [ectNorm, ectOneBase, ectOneCurr, ectOneIndx, ectVolume,
                                         ectVolBase, ectVolCurr, ectVolIndx, ectTotBase, ectTotCurr];
  /// Типы цен, используемые в итогах разделов смет
  EstChpCostTypes: TEstimateCostTypes = [ectBase, ectCurr,ectTotBase, ectTotCurr, ectChpBase, ectChpCurr];
  /// Типы цен, используемые в итогах смет
  EstEstCostTypes: TEstimateCostTypes = [ectBase, ectCurr,ectTotBase, ectTotCurr];
  /// Типы цен, используемые в ресурсах позиций смет
  EstResCostTypes: TEstimateCostTypes = [ectBase, ectCurr];
  EstCurrentPriceCostTypes: TEstimateCostTypes = [ectCurr, ectOneCurr, ectVolCurr, ectTotCurr, ectTotCurr];
  EstBasePriceCostTypes: TEstimateCostTypes = [ectBase, ectOneBase, ectVolBase, ectTotBase, ectTotBase];

type
  /// Тип применяемого индекса перевода в текущий уровень цен
  // eitNone    - Отсутствует
  // eitUnified - Единый   (СМР)
  // eitCosts   - по видам затрат
  // eitWorks   - Работы
  // eitItems   - для каждой позиции
  TEstimateIndexType = (eitNone, eitUnified, eitCosts, eitWorks, eitItems);
  TEstimateIndexTypes = set of TEstimateIndexType;

  /// Тип сборников НР и СП
  // eopnMDS     - МДС
  // eopnNew     - новые приказы
  // eopnUnknown - неопределено
  TEstimateOPNorm = (eopnMDS, eopnNew, eopnUnknown);
  TEstimateOPNorms = set of TEstimateOPNorm;

  /// Флаг региона в отношении районы крайнего севера и приравненные к районам крайнего севера
  // nrfNone     - смета составлена для объекта в регионе не относящемуся к крайнему северу
  // nrfNord     - смета составлена для объекта в районе крайнего севера                         (РКС)
  // nrfEquate   - смета составлена для объекта в регионе приравненном к районам крайнего севера (МПРКС)
  // nrfUndefine - флаг не определён
  TNordRegionFlag = (nrfNone, nrfNord, nrfEquate, nrfUndefine);

  /// Вид сметы
  // ekMDS421pr - смета составлена по правилам МДС-421пр(FER)
  // ekMDS557pr - смета составлена по правилам МДС-557пр(FER)
  // ekTSN      - смета составлена по правилам TSN(MNB)
  // ekSN2012   - смета составлена по правилам СН-2012(MNB)
  // ekSSN421pr - смета составлена по правилам МДС-421пр с использованием расценок ССН-84()
  // ekSSN557pr - смета составлена по правилам МДС-557пр с использованием расценок ССН-84
  // ek557RIM   -
  // ek557RM    -
  // ekTIM      -
  // ekNone     - просто смета
  TEstimateKind = (ekMDS421pr, ekMDS557pr, ekMDS55pr, ekTSN, ekSN2012, ekSSN421pr, ekSSN557pr, ek557RIM, ek557RM, ekTIM, ekNone);
  /// Набор видов смет
  TEstimateKinds = set of TEstimateKind;

  /// Сметные методики  //TODO: ввести в смету
  // emMDS421pr - смета составлена по правилам МДС-421пр
  // emMDS557pr - смета составлена по правилам МДС-557пр
  // emMDS55pr  - смета составлена по правилам МДС-55пр
  // emMDS30pr  - смета составлена по правилам МДС-30пр
  // emMDS42pr  - смета составлена по правилам МДС-42пр
  // emUndefine - старые методики
  // emNone     - методика не установлена
  TEstimateMetodic=(emMDS421pr, emMDS557pr, emMDS55pr, emMDS30pr, emMDS42pr, emUndefine, emNone);


{
Тип документа согласно классификатору `tDocumentType`. Обязателен для заполнения.
ЛСР - локальный сметный расчет;
ОСР - объектный сметный расчет;
ССРСС - сводный сметный расчет стоимости строительства;
КАЦ - конъюнктурный анализ;
КАД - обосновывающие документы к КАЦ;
ВОР - ведомость объемов работ;
СЗ - сводка затрат;
СВОР - сопоставительная ведомость объемов работ;
СВИС - сопоставительная ведомость изменения стоимости;
СР - Калькуляция сметных расчётов на отдельные виды затрат;
СР1 - калькуляция расценок (ФСНБ-2022 → БИМ);
СР2 - калькуляция сметных расчетов на отдельные виды затрат (калькуляции 1, новый карьер);
СР3 - калькуляция сметных расчетов на отдельные виды затрат (калькуляции 3, др. регион);
СР4 - калькуляция сметных расчетов на отдельные виды затрат (для ССР);
ТС - транспортная схема;
ДР - другие документы.}
  /// Тип сметного документа
  // edtLEC - локальный сметный расчёт  ЛСР - локальный сметный расчет;
  // edtOEC - объектный сметный расчёт  ОСР - объектный сметный расчет;
  // edtSEC - сводный сметный расчёт    ССРСС - сводный сметный расчет стоимости строительства;
  // edtMA - конъюктурный анализ        КАЦ - конъюнктурный анализ;
  // edtMAD -                                   КАД - обосновывающие документы к КАЦ;
  // edtLOV - ведомость объёмов работ   ВОР - ведомость объемов работ;
  // edtCS - сводка затрат              СЗ - сводка затрат;
  // edtCSWV - СВОР - сопоставительная ведомость объекмов работ;             Comparative Statement of Work Volumes
  // edtCSCEC - СВИС - сопоставительная ведомость изменения стоимости;       Comparative Statement of Changes in Estimated Costs
  // edtCalc - СР - Калькуляция сметных расчётов на отдельные виды затрат;
  // edtCalc1 - СР1 - калькуляция расценок (ФСНБ-2022 → БИМ);
  // edtCalc2 - СР2 - калькуляция сметных расчетов на отдельные виды затрат (калькуляции 1, новый карьер);
  // edtCalc3 - СР3 - калькуляция сметных расчетов на отдельные виды затрат (калькуляции 3, др. регион);
  // edtCalc4 - СР4 - калькуляция сметных расчетов на отдельные виды затрат (для ССР);
  // edtTrans - ТС - транспортная схема;
  // edtOther - ДР - другие документы.
  // edtExpl - пояснительная записка
  TEstDocType = (edtLEC, edtOEC, edtSEC, edtMA, edtMAD, edtCS, edtLOV, edtCSWV, edtCSCEC,
                 edtCalc, edtCalc1, edtCalc2, edtCalc3, edtCalc4,
                 edtTrans, edtOther, edtExpl,
                 edtNone);
  TEstDocTypes = set of TEstDocType;

  /// Метод расчета локальной сметы
  // ecmBIM - базисно-индексный метод
  // ecmRM  - ресурсный метод
  // ecmRIM - ресурсно-индексный метод
  // ecmTSN - ТСН
  // ecmTIM - использование ТИМ
  TEstCalcMethod = (ecmBIM, ecmRM, ecmRIM, ecmTSN, ecmTIM, ecmUndefined);

const
  /// Стоимость в базисом уровне цен
  EstimatePricesBase: TEstimatePriceKinds = [epkNorm, epkOneBase, epkVolume, epkVolBase, epkTotBase];
  /// Стоимость в текущем уровне цен
  EstimatePricesCurr: TEstimatePriceKinds = [epkOneCurr, epkOneIndx, epkVolCurr, epkVolIndx, epkTotCurr];
  /// Стоимость за единицу объёма
  EstimatePricesOne: TEstimatePriceKinds = [epkNorm, epkOneBase, epkOneCurr, epkOneIndx];
  /// Стоимость за полный объём
  EstimatePricesVol: TEstimatePriceKinds = [epkVolBase, epkVolume, epkVolCurr, epkVolIndx];
  /// Стоимсоть за полный объём с учетом поправок
  EstimatePricesTot: TEstimatePriceKinds = [epkTotBase, epkTotCurr];

type

  /// Принадлежность к видам затрат объектной сметы и сводного сметного расчета, а также виды комментария
  // Вид работ позиции в соответствии с технологической структурой капитальных вложений:
  // ewtConstruction - строительные работы
  // ewtInstallation - монтаж
  // ewtOverhaul     - капитальный ремонт                                 НР=0.9 СП=0.85
  // ewtOverhaulBld  - капитальный ремонт производственных сооружений            СП=0.85
  // ewtRestoration  - реставрация
  // ewtReconstruction- реконструкция
  // ewtdemolition   - снос
  // ewtEquipment    - оборудование
  // ewtPortage      - перевозка
  // ewtLoading      - погрузка
  // ewtOther        - прочие затраты (ewtExpenses + ewtOtherWorks)
  // ewtOtherWorks   - прочие работы, связанные с пусконаладочными работами (пп.122-128 МДС 421/пр)
  // ewtExpenses     - прочие затраты, связанные с созданием монументальных произведений исскуства (п.184 МДС 421/пр)
  // ewtStartup      - пусконаладочные работы
  // ewtTotals       - итоги
  // Комментарии:
  // ewtPosComment   - комментарий на уровне позиции
  // ewtChpComment   - комментарий на уровне раздела
  // ewtEstComment   - комментарий на уровне позиции
  // ewtEmpty        - пустое значение
  // ewtUndefine     - не задано
  // для смет используются ewtConstruction или ewtRestoration
  TEstimateWorkType = (ewtConstruction, ewtInstallation, ewtRestoration, ewtDemolition,
                       ewtReconstruction, ewtOverhaul, ewtOverhaulBld,
                       ewtEquipment, ewtPortage, ewtStartup,
                       ewtOther, ewtOtherWorks, ewtExpenses,
                       ewtTotals, ewtLoading,
                       ewtPosComment, ewtChpComment, ewtEstComment,
                       ewtEmpty, ewtUndefine);
  /// Набор видов работ (затрат)
  TEstimateWorkTypes = set of TEstimateWorkType;

const
  ///
  EstEstimateWT: TEstimateWorkTypes = [ewtConstruction, ewtRestoration];
  /// Виды работ в локальной смете Турбо-сметчика (влияют на коэффициенты НРСП)
  EstEstimateWTx: TEstimateWorkTypes = [ewtConstruction, ewtReconstruction, ewtOverhaul, ewtOverhaulBld];
  /// Набор видов работ, соответствующий строке комментария
  EstCommentWT: TEstimateWorkTypes = [ewtPosComment, ewtChpComment, ewtEstComment];
  /// Набор видов работ, допустимых к использованию в сметах
  EstRegularWT: TEstimateWorkTypes = [ewtConstruction, ewtInstallation, ewtRestoration, ewtEquipment, ewtPortage,
                                      ewtOther, ewtOtherWorks, ewtExpenses, ewtTotals];
  /// Графы объектной сметы
  EstObjectWT: TEstimateWorkTypes = [ewtConstruction, ewtInstallation, ewtEquipment, ewtOther];
  /// Набор видов работ, недопустимых к использованию в сметах
  EstUndefineWT: TEstimateWorkTypes = [ewtUndefine];

type

/// Виды расценок по типу расходов
// Construction – строительные,
// Repair – ремонтно-строительные,
// Installation – монтажные,
// Startup – пуско-наладочные,
// Portage – перевозка,
// Material – материал,
// Mechanism – машина, механизм,
// Workers - трудозатраты основных рабочих,
// Drivers – трудозатраты машинистов,
// Integrated – укрупненные расценки,
// PriceList – прейскуранты,
// Restoration – ремонтно-реставрационные,
// Equipment – техническое обслуживание и ремонт оборудования,
// Maintenance – праздничное, тематическое оформление города, содержание объектов городской среды,
// Other – прочие.
  TEstimatePositionKind = (epkConstruction, epkRepair, epkInstallation, epkStartup,
                           epkPortage, epkMaterial, epkMechanism, epkWorkers,
                           epkDrivers, epkIntegrated, epkPriceList, epkRestoration, epkEquipment, epkMaintenance, epkOther);

  /// Категория расценки
  // epcConstruction   - строительство
  // epcInstallation   - монтаж
  // epcRepair         - ремонт
  // epcRebuilding     - капитальный ремонт
  // epcReconstruction - реставрация
  // epcStartup        - пусконаладка
  // epcSalary         - зарплата
  // epcMachines       - машина или механизм
  // epcMaterial       - материал
  // epcEquipment      - оборудование
  // epcPortage        - перевозка
  // epcPortageMat     - перевозка материалов
  // epcPortageEqu     - перевозка оборудования
  // epcMarket         - Рыночная позиция в МА
  // epcFSBC           - Позиция из Справочника в МА
  // epcAggregative    - укрупнённая расценка
  // epcOther          - прочее
  // epcUndefine       - неопределено
  TEstimatePositionCategory = (epcConstruction, epcInstallation, epcRepair, epcRebuilding, epcReconstruction, epcStartup,
                               epcSalary, epcMachines, epcMaterial, epcEquipment,
                               epcPortage, epcPortageMat, epcPortageEqu, epcLoading,
                               epcWorker, epcMachinist, epcMachinistAdd,
                               epcAggregative, epcOther, epcUndefine);
  /// Набор категорий расценок
  TEstimatePositionCategories = set of TEstimatePositionCategory;

const
  EstPosConstructionCategories:   TEstimatePositionCategories = [epcConstruction, epcRepair, epcRebuilding];
  EstPosInstallationCategories:   TEstimatePositionCategories = [epcInstallation];
  EstPosEquipmentCategories:      TEstimatePositionCategories = [epcEquipment];
  EstPosOtherCategories:          TEstimatePositionCategories = [epcOther, epcStartup];
  EstPositionCategories:          TEstimatePositionCategories = [epcConstruction, epcInstallation, epcRepair, epcRebuilding,
                                                                 epcOther, epcStartup];
  EstPosPortageCategories:        TEstimatePositionCategories = [epcPortage, epcPortageMat, epcPortageEqu, epcLoading];
  EstPosResourceCategories:       TEstimatePositionCategories = [epcMachines, epcMaterial, epcEquipment,
                                                                 epcPortageMat, epcPortageEqu, epcLoading];
  EstFreeResourceCategories:      TEstimatePositionCategories = [epcMaterial, epcEquipment, epcPortage, epcLoading];
  EstPortagedResourcesCategories: TEstimatePositionCategories = [epcMaterial, epcEquipment];
  EstResourcePortageCategories:   TEstimatePositionCategories = [epcPortageMat, epcPortageEqu];
  EstPosLaborCategories:          TEstimatePositionCategories = [epcWorker, epcMachinist, epcMachinistAdd, epcSalary];

type

  /// Типы позиций/расценок
  // ! eptFER    = ФЕР     Федеральные единичные расценки на строительные и специальные строительные работы
  // ! eptFERm   = ФЕРм    Федеральные единичные расценки на монтаж оборудования
  // ! eptFERmr  = ФЕРмр   Федеральные единичные расценки на капитальный ремонт оборудования
  // ! eptFERr   = ФЕРр    Федеральные единичные расценки на ремонтно-строительные работы
  // ! eptFERp   = ФЕРп    Федеральные единичные расценки на пусконаладочные работы
  // ! eptFSSC   = ФССЦ    Федеральные сметные цены на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  // ! eptFSSCpg = ФССЦпг  Федеральные сметные цены на перевозки грузов для строительства
  // ! eptFSEM   = ФСЭМ    Федеральные сметные расценки на эксплуатацию строительных машин и автотранспортных средств
  // ! eptFSBC   = ФСБЦ    Федеральные сметные цены на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  // ! eptFSBCm  = ФСБЦм
  // ! eptFSBCm  = ФСБЦпг
  // ! eptTER    = ТЕР     Территориальные сметные расценки на строительные и специальные строительные работы
  // ! eptTERm   = ТЕРм    Территориальные сметные расценки на монтаж оборудования
  // ! eptTERmr  = ТЕРмр   Территориальные сметные расценки капитальный ремонт оборудования
  // ! eptTERr   = ТЕРр    Территориальные сметные расценки на ремонтно-строительные работы
  // ! eptTERp   = ТЕРп    Территориальные сметные расценки на пусконаладочные работы
  // ! eptTSSC   = ТССЦ    Территориальные сметные цены на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  // ! eptTSSCpg = ТССЦпг  Территориальные сметные цены на перевозки грузов для строительства
  // ! eptTSEM   = ТСЭМ    Территориальные сметные расценки на эксплуатацию строительных машин и автотранспортных средств
  // ! eptGESN   = ГЭСН    ГЭСН-2001 - Общестроительные работы.
  // ! eptGESNm  = ГЭСНм   ГЭСНм-2001 - Монтажные работы.
  // ! eptGESNmr = ГЭСНмр  ГЭСНмр-2001 - Капитальный ремонт оборудования.
  // ! eptGESNr  = ГЭСНр   ГЭСНр-2001 - Ремонтные работы.
  // ! eptGESNp  = ГЭСНп   ГЭСНп-2001 - Пусконаладочные работы.
//Материалы ФСНБ-2001
//Трудовые ресурсы ФСНБ-2001
//Перевозка грузов ФСНБ-2001
  // ! eptKSR    = КСР     Классификатор строительных ресурсов – КСР 2016 (ГЭСН-2017 и ФЕР-2017)
  // ! eptTSN    = ТСН     База сметных нормативов ТСН-2001 (Москва)
  // ! eptSN1012 = СН2012     База сметных нормативов ТСН-2001 (Москва)
  // ! eptOERG   = ОЕРЖ    Отраслевая сметно-нормативная база ОАО "РЖД"  Отраслевые единичные расценки на строительные и специальные строительные работы
  // ! eptOERGm  = ОЕРЖм   Отраслевые единичные расценки на монтаж оборудования
  // ! eptOERGr  = ОЕРЖр   Отраслевые единичные расценки на ремонтно-строительные работы
  // ! eptOERGp  = ОЕРЖп   Отраслевые единичные расценки на пусконаладочные работы
  // ! eptOERGmr = ОЕРЖмр  Отраслевые единичные расценки на капитальный ремонт оборудования
  // ! eptOERGkr = ОЕРЖкр  Отраслевые единичные расценки на капитальный ремонт объектов железнодорожного транспорта
  // ! eptOSCGo  = ОСОЦЖо  Отраслевые отпускные цены на оборудование
  // ! eptOSSCG  = ОССЦЖ   Отраслевые сметные цены на материалы, изделия и конструкции (РЖД)
  // ! eptOSSPG  = ОССПЖ   Отраслевые сметные цены на перевозки грузов для строительства (РЖД)
  // ! eptOSEMG  = ОСЭМЖ   Отраслевые сметные расценки на эксплуатацию строительных машин и автотранспортных средств (РЖД)
  // ! eptPriceMat = ПрайсМатериал
  // ! eptPriceEqu = ПрайсОборудование
//ОЭСНЖ-2001 Отраслевые элементные сметные нормы на строительные и специальные строительные работы
//ОЭСНЖм-2001 Отраслевые элементные сметные нормы на монтаж оборудования
//ОЭСНЖкр-2001 Отраслевые элементные сметные нормы на капитальный ремонт объектов железнодорожного транспорта
//ОЕРтр Отраслевые единичные расценки на работы по техническому обслуживанию и ремонту оборудования городского хозяйства
  // ! eptPIR     - расценки ПИР
  // ! eptTariff  - трудовые ресурсы
  // ! eptComment - строка комментария
  // ! eptLEC     - строка с данными локальной сметы
  // ! eptOEC     - строка с данными объектной сметы
  // ! eptSEC     - строка с данными сводной сметы
  // ! eptMP      - ССН-84 сборник на реставрацию и строительство монументов от МинКульта
  // ! eptUnknown - неизвестрый
  TEstimatePositionType = (eptFER, eptFERm, eptFERmr, eptFERr, eptFERp, eptFSSC, eptFSSCpg, eptFSEM, eptFSBC, eptFSBCm, eptFSBCpg,
                           eptTER, eptTERm, eptTERmr, eptTERr, eptTERp, eptTSSC, eptTSSCpg, eptTSEM,
                           eptGESN, eptGESNm, eptGESNmr, eptGESNr, eptGESNp,
                           eptKSR, eptTSN,
                           eptOERG, eptOERGm, eptOERGr, eptOERGp, eptOERGmr, eptOERGkr,
                           eptOSCGo, eptOSSCG, eptOSSPG, eptOSEMG,
                           eptPriceMat, eptPriceEqu,
                           eptPIR, eptTariff, eptComment,
                           eptLEC, eptOEC, eptSEC,
                           eptMP,
                           eptMarket,
                           eptUnknown);
  /// Набор типов позиций/расценок
  TEstimatesPositionTypes = set of TEstimatePositionType;
  /// Массив наборов типов расценок соответствующих катергориям расценок
  TEstPosTypesInNormBaseCategories = array[ebcConstruction..ebcPortage] of TEstimatesPositionTypes;

  /// Массив строк с наименованиями ресурсов
  TEstPositionTypeNames = array[eptFER..eptUnknown] of string;
  /// Массив строк с наименованиями ресурсов
  TEstPositionTypeNamesUTF8 = array[eptFER..eptUnknown] of RawUTF8;

const
  /// Набор типов для расценки из прайс-листов
  EstimatePositionPriceLists: TEstimatesPositionTypes = [eptPriceMat, eptPriceEqu];
  /// Набор типов для расценки ФЕР
  EstimatePositionsFER: TEstimatesPositionTypes = [eptFER, eptFERm, eptFERmr, eptFERr, eptFERp, eptFSSC, eptFSSCpg, eptFSEM,
                                                   eptFSBC, eptFSBCm, eptFSBCpg];
  /// Набор типов для расценки ТЕР
  EstimatePositionsTER: TEstimatesPositionTypes = [eptTER, eptTERm, eptTERmr, eptTERr, eptTERp, eptTSSC, eptTSSCpg, eptTSEM];
  /// Набор типов для расценки РЖД
  EstimatePositionsRZD: TEstimatesPositionTypes = [eptOERG, eptOERGm, eptOERGmr, eptOERGr, eptOERGp, eptOERGkr, eptOSCGo,
                                                   eptOSSCG, eptOSSPG, eptOSEMG];
  /// Набор типов для расценки ГЭСН
  EstimatePositionsGESN: TEstimatesPositionTypes = [eptGESN, eptGESNm, eptGESNmr, eptGESNr, eptGESNp];

  /// Набор типов для расценки на строительные и специальные строительные работы
  EstimatePositionsConstruction: TEstimatesPositionTypes = [eptFER, eptTER, eptOERG, eptGESN, eptTSN];
  /// Набор типов для расценки на монтаж оборудования
  EstimatePositionsInstallation: TEstimatesPositionTypes = [eptFERm, eptTERm, eptOERGm, eptGESNm, eptTSN];
  /// Набор типов для расценки на ремонтно-строительные работы
  EstimatePositionsRepair: TEstimatesPositionTypes = [eptFERr, eptTERr, eptOERGr, eptGESNr, eptTSN];
  /// Набор типов для расценки на пусконаладочные работы
  EstimatePositionsStartingUp: TEstimatesPositionTypes = [eptFERp, eptTERp, eptOERGp, eptGESNp, eptTSN];
  /// Набор типов для расценки на капитальный ремонт оборудования
  EstimatePositionsReconstruction: TEstimatesPositionTypes = [eptFERmr, eptTERmr, eptOERGmr, eptGESNmr, eptTSN];
  /// Набор типов для сметные цены на перевозки грузов для строительства
  EstimatePositionsPortage: TEstimatesPositionTypes = [eptFSSCpg, eptFSBCpg, eptTSSCpg, eptOSSPG];
  /// Набор типов для расценки на эксплуатацию строительных машин и автотранспортных средств
  EstimatePositionsMachines: TEstimatesPositionTypes = [eptFSEM, eptTSEM, eptOSEMG];
  /// Набор типов для расценки на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  EstimatePositionsMaterials: TEstimatesPositionTypes = [eptFSSC, eptFSBC, eptFSBCm, eptTSSC, eptOSSCG, eptPriceMat];
  /// Набор типов для расценки на материалы, изделия, конструкции и оборудование, применяемые в строительстве
  EstimatePositionsEquipments: TEstimatesPositionTypes = [eptFSSC, eptFSBC, eptFSBCm, eptTSSC, eptOSCGo, eptPriceEqu];

  EstimatePositionsResources: TEstimatesPositionTypes = [eptFSSC, eptTSSC, eptOSSCG, eptOSCGo, eptPriceMat, eptPriceEqu,
                                                         eptFSEM, eptTSEM, eptOSEMG, eptTariff];
var
  /// Массив строк с наименованиями типов расценок
  EstPositionTypeNames: TEstPositionTypeNames;
  /// Массив строк с наименованиями типов расценок
  EstPositionTypeNamesUTF8: TEstPositionTypeNamesUTF8;

type

  /// Элементы стоимости позиции (расценки)
  // eppiDirect    - прямые затраты
  // eppiWorker    - зарплата основных рабочих
  // eppiMachines  - затраты на экслуатацию машин и механизмов
  // eppiMachinist - зарплата механиков и машинистов
  // eppiMaterials - стоимость материалов
  // eppiEquipment - стоимость оборудования
  TEstPositionPriceItemType = (eppiDirect, eppiWorker, eppiMachines, eppiMachinist, eppiMaterial, eppiEquipment);
  /// Набор элементов стоимости позиции (расценки)
  TEstPositionPriceItemTypes = set of TEstPositionPriceItemType;
  /// Массив значений элементов стоимости позиции (расценки)
  TEstPositionPriceItems = array[eppiDirect..eppiEquipment] of Double;

  /// Элементы затрат труда
  // epliWorker    - затраты труда основных рабочих
  // epliMachinist - затраты труда механиков и машинистов
  TEstPositionLaborItemType = (epliWorker, epliMachinist, epliLabour, epliUndefined);
  /// Набор элементов затрат труда
  TEstPositionLaborItemTypes = set of TEstPositionLaborItemType;
  /// Массив значений элементов затрат труда
  TEstPositionLaborItems = array[epliWorker..epliLabour] of Double;

  /// Типы натуральных показателей
  // entWorker       - затраты труда основных рабочих
  // entMachinist    - затраты труда механиков и машинистов
  // entLabour       - общая работа
  // entDebris       - масса мусора
  // entGroundWeight - масса грунта
  // entGrountVolume - объём грунта
  // entEquipment    - масса оборудования
  // entReturns      - стоимость возвращаемых материалов
  TEstNaturalType = (entWorker, entMachinist, entLabour, entDebris, entGroundWeight, entGroundVolume,
                     entEquipment, entReturns,
                     entUndefined
                    );
  /// Набор типов натуральных показателей
  TEstNaturalsTypes = set of TEstNaturalType;

  /// Натуральный показатель
  TEstNaturalItem = record
    CostType: TEstimateCostType;
    ItemType: TEstNaturalType;
    Value: Double;
  end;

  /// Массив значений натуральных показателей
  TEstNaturalItemDynArray = array of TEstNaturalItem;

const
  EstLabourItems: TEstNaturalsTypes = [entWorker, entMachinist, entLabour];

type

  /// Элемент трудозатрат
  TEstLabourInputItem = record
    CostType: TEstimateCostType;
    ItemType: TEstPositionLaborItemType;
    Value: Double;
  end;

  /// Массив элементов трудозатрат
  TEstLabourInputItemDynArray = array of TEstLabourInputItem;

  /// Методика расчёта стоимости позиции сметы
  //! epmElements - поэлементно
  //! epmAverage  - средневзвешенно
  //! epmPortage  - перевозка
  //! epmDirect   - расчет по ПЗ
  //! epmCustom   - пользовательская
  TEstimatePositionMethodic = (epmElements, epmAverage, epmPortage, epmDirect, epmCustom);

  /// Типы ресурсов
  // ertWorker    - затраты труда основных рабочих              (ЗТР)
  // ertMachinist - затраты труда машинистов и механиков        (ЗТМ)
  // ertMachines  - машины и механизмы                          (ЭММ)
  // ertMaterial  - строительные материалы                      (МАТ)
  // ertEquipment - оборудование                                (ОБ)
  // ertPortage   - перевозка
  // ertOther     - прочие ресурсы
  // ertUndefined - неопределено
  TEstimateResourceType = (ertNone, ertWorker, ertMachinist, ertMachines, ertMaterial, ertEquipment, ertPortage, ertOther, ertUndefined);
  /// Набор типов ресурсов
  TEstimateResourceTypes = set of TEstimateResourceType;

  /// Виды ресурсов
  // erkInternal      - внутренние (учтённые) ресурсы
  // erkSubordinated  - подчинённые расценке ресурсы
  // erkFree          - свободные ресурсы, представленные в смете в виде отдельных позиций
  TEstimateResourceKind = (erkInternal, erkSubordinated, erkFree);
  /// Набор видов ресурсов
  TEstimateResourceKinds = set of TEstimateResourceKind;

  /// Виды ресурсных позиций
  // eritExternal     - внешний ресурс, замещающий неучтённый ресурс
  // eritFree         - свободный ресурс, не связанный с какой-либо расценкой
  // eritInternal     - учтённый в расценке ресурс
  // eritReplaced     - заменяемый учтённый в расценке ресурс
  // eritSubstitute   - ресурс, замещающий учтённый ресурс
  // eritUnaccounted  - неучтённый в расценке ресурс
  // eritUndefined    - неопределенный ресурс
  TEstimateResourceItemType = (eritInternal, eritExternal, eritFree, eritReplaced, eritSubstitute, eritUnaccounted, eritUndefined);
const
  /// Валидные типы ресурсов
  ValidResourceTypes = [ertWorker, ertMachinist, ertMachines, ertMaterial, ertEquipment];

type

  /// Массив строк с наименованиями ресурсов
  TEstResourceTypeNames     = array[ertWorker..ertEquipment] of string;
  /// Массив строк с наименованиями ресурсов
  TEstResourceTypeNamesUTF8 = array[ertWorker..ertEquipment] of RawUTF8;

type
  /// Тип поправки
  // 0 – коэффициент учета инфляции (коэффициент пересчета сметных цен),
  // 1 – коэффициент зимнего удорожания,
  // 2 – норматив накладных расходов в базовых и текущих ценах,
  // 3 – норматив сметной прибыли в базовых и текущих ценах,
  // 4 – норматив накладных расходов в базовых ценах,
  // 5 – норматив сметной прибыли в базовых ценах,
  // 6 – норматив накладных расходов в текущих ценах,
  // 7 – норматив сметной прибыли в текущих ценах,
  // 8 – коэффициент учета условий работ,
  // 10 – прочие коэффициенты.
  TEstimateCorrectionType = (ectIndex, ectWinter, ectOverHeadBC, ectProfitBC, ectOverheadB, ectProfitB,
                             ectOverheadC, ectProfitC, ectCondition, ectOther);

  /// Виды поправочных коэффициентов
  // eckPosition
  // eckResource
  // eckIndex
  // eckOverheadOrProfit
  TEstimateCoefficientKind = (eckPosition, eckResource, eckIndex, eckOverheadOrProfit);

  /// Категория поправочного коэффициента
  // eccRegular   - обычный коэффициент (значение задаётся в виде константы)
  // eccComposite - составной коэффициент (значение вычисляется)
  // eccRounded2  - значение округляется до двух знаков
  // eccFinal     - итоговый коэффициент (значение вычисляется)
  // eccNoMachinistAdd - заглушка для удаления атрибута ecsaMachinistAdd
  TEstimateCoefficientCategory = (eccRegular, eccComposite, eccRounded2, eccFinal, eccNoMachinistAdd);

  /// Особенности расчёта коэффициентов
  // ecsaMachinistAdd - нужно учитывать наличие доплаты машинистов
  // ecsaNone         - обычный расчёт
  TEstimateCoefficientSpecialAttribute = (ecsaMachinistAdd, ecsaNone);

  /// Набор особенностей расчёта коэффициентов
  TEstimateCoefficientSpecialAttributes = set of TEstimateCoefficientSpecialAttribute;

  /// К чему применяются
  // evtDirect          - прямые затраты                            (ПЗ)
  // evtWorkerSalary    - зарплата основных рабочих                 (ОЗП)
  // evtMachines        - стоимость эксплуатации машин и механизмов (ЭМ)
  // evtMachinistSalary - зарплата машинистов                       (ЗПМ)
  // evtMaterial        - стоимость материалов                      (МТ)
  // evtEquipment       - стоимость оборудования                    (ОБ)
  // evtWorkerLabor     - затраты труда основных рабочих            (TЗ)
  // evtMachinistLabor  - затраты труда машинистов                  (ЗТМ)
  // evtPrice           - стоимость (ресурса)
  // evtVolume          - объем
  // evtConsumption     - расход                                    (Расход)
  // evtWageFund        - фонд оплаты труда                         (ФОТ)
  // evtCIW             - СМР                                       (СМР)
  // evtOverheadBC      - норматив накладных расходов в базовых и текущих ценах
  // evtProfitBC        - норматив сметной прибыли в базовых и текущих ценах
  // evtOverheadB       - норматив накладных расходов в базовых ценах
  // evtProfitB         - норматив сметной прибыли в базовых ценах
  // evtOverheadC       - норматив накладных расходов в текущих ценах
  // evtProfitC         - норматив сметной прибыли в текущих ценах
  // evtPortage         - транспортные расходы
  // evtStartUp         - пусконаладочные работы
  // evtOther           - прочие расходы
  // evtNone            - без цели
  TEstimateValueTarget = (evtDirect, evtWorkerSalary, evtMachines, evtMachinistSalary, evtMaterial, evtEquipment,
                          evtWorkerLabor, evtMachinistLabor, evtWorkerFund, evtMachinistFund,
                          evtPrice, evtVolume, evtConsumption, evtWageFund, evtCIW,
                          evtOverheadBC, evtProfitBC, evtOverheadB, evtProfitB, evtOverheadC, evtProfitC,
                          evtPortage, evtStartUp, evtOther,
                          evtNone);
  TEstimateValueTargets = set of TEstimateValueTarget;
  /// Массив строк, содержащих названия целей применения нормативов и коэффициентов
  TEstValueTargetNamesUTF8 = array[evtDirect..evtNone] of RawUTF8;
  TEstValueTargetNames = array[evtDirect..evtNone] of string;

  /// Тип раздела
  // echChapter - раздел с позициями сметы
  // echNote    - комментарии
  TEstimateChapterType = (echChapter, echNote);

const
  /// Набор целей применения нормативов накладных расходов и сметной прибыли
  EstOverhedProfitTargets: TEstimateValueTargets = [evtDirect, evtWorkerSalary, evtMachinistSalary, evtWageFund];
  /// Набор целей применения поправочных коэффициентов к расценкам
  EstPositionCoefValueTargets: TEstimateValueTargets = [evtDirect, evtWorkerSalary, evtMachines, evtMachinistSalary,
                                                        evtMaterial, evtEquipment, evtWorkerLabor, evtMachinistLabor];
  /// Набор целей применения частного значения индекса к расценкам
  EstPositionIndexValueTargets: TEstimateValueTargets = [evtDirect, evtWorkerSalary, evtMachines, evtMachinistSalary,
                                                        evtMaterial, evtEquipment, evtWorkerLabor, evtMachinistLabor];
  /// Набор целей применения поправочных коэффициентов к ресурсам
  EstResourceCoefValueTargets: TEstimateValueTargets = [evtDirect, evtWorkerSalary, evtMachines, evtMachinistSalary,
                                                        evtMaterial, evtEquipment, evtWorkerLabor, evtMachinistLabor,
                                                        evtConsumption];
  /// Набор целей применения поправочных коэффициентов к объёмам работ и ресурсов
  EstVolumesTarget: TEstimateValueTargets = [evtVolume, evtConsumption];

/// Функция конвертирует строку в Target и возвращает true в случае успеха
function EstValueTargetFromStr(const S: string; out Trg: TEstimateValueTarget): boolean;
/// Функция возвращает значение ValueTarget для заданного PriceItem
function EstValueTargetFromPriceItem(const epi: TEstimatePriceItemType): TEstimateValueTarget;

var
  /// Массив наименований элементов стоимости
  EstPositionPriceNames: array[eppiDirect..eppiEquipment,epkNorm..epkTotCurr] of string;
  /// Массив наименований элементов стоимости
  EstPositionPriceNamesUTF8: array[eppiDirect..eppiEquipment,epkNorm..epkTotCurr] of RawUTF8;
  /// Массив наименований целей воздействия
  EstValueTargetNamesUTF8: TEstValueTargetNamesUTF8;
  /// Массив наименований целей воздействия
  EstValueTargetNames: TEstValueTargetNames;
  /// Массив наименований типов ресурсов
  EstResourceTypeNames: TEstResourceTypeNames;
  /// Массив наименований типов ресурсов
  EstResourceTypeNamesUTF8: TEstResourceTypeNamesUTF8;

  EstResourceCypherMask: string;
  EstPositionCypherMask: string;

type
   /// типы итоговых строк объектных и сводных сметных расчётов
   // eskSubsummary    - строка с промежуточными итогами по графам объектной сметы
   // eskTempBuildings - затраты на строительство титульных временных зданий и сооружений
   // eskWinter        - дополнительные затраты при производстве работ в зимнее время
   // eskAdditions     - прочие дополнительные затраты
   // eskSnow          - лимит затрат на борьбу со снегом
   // eskCalculation   - итоги сметных расчётов на отдельные виды затрат в составе сводного сметного расчёта
   // eskLocEstimate   - итоги локальной сметы в составе сводного сметного расчёта
   // eskObjEstimate   - итоги объетной сметы в составе сводного сметного расчёта
   // eskTotals        - суммированные итоги
   // eskDummy         - пустая строка
   // eskUndefined     - неопределено
   TEstimateSummaryKind = (eskSubsummary, eskTempBuildings, eskWinter, eskAdditions, eskSnow,
                           eskCalculation, eskLocEstimate, eskObjEstimate, eskTotals,
                           eskDummy, eskUndefined);
   TEstimateSummaryKinds = set of TEstimateSummaryKind;

  /// Типы организаций
  //  eokContractor - порядчик
  //  eokSubcontractor - субподрядчик
  //  eokCustomer - заказчик
  //  eokGeneral - генеральный заказчик
  //  eokDeveloper - разработчик
  //  eokInvestor - инвестор
  //  eokSupplier - поставщик
  //  eokVendor - производитель
  //  eokOther - иное
  TEstOrganisationKind = (eokContractor, eokSubcontractor, eokCustomer, eokGeneral, eokDeveloper, eokInvestor,
                          eokSupplier, eokVendor,
                          eokOther);
  /// Наборр типов организаций
  TEstOrganisationKinds = set of TEstOrganisationKind;

  /// Коды должностей
  // ejcChiefProjectEngineer - главный руководитель проекта
  // ejcChiefAccountant  - главный бухгалтер
  // ejcManager         - руководитель
  // ejcHeadmaster      - директор
  // ejcDraftsman       - составитель
  // ejcChecker         - проверяющий
  // ejcExecutive       - исполнитель
  // ejcCustomer        - заказчик
  // ejcDeveloper       - застройщик (технический заказчик)
  // ejcUndefine        - неопределено
  TEstJobCode = (ejcChiefAccountant, ejcChiefProjectEngineer, ejcDraftsman, ejcChecker, ejcHeadmaster, ejcManager, ejcExecutive,
                 ejcCustomer, ejcDeveloper, ejcUndefine);
  /// Набор кодов должностей
  TEstJobCodes = set of TEstJobCode;

  /// Опции списка
  // eloCaseInsensible
  // eloIgnoreDouble
  // eloReplasceDouble
  TEstListOption = (eloCaseInsensible, eloIgnoreDouble, eloReplasceDouble);
  /// набор опций списка
  TEstListOptions = set of TEstListOption;

  /// Тип реквизита
  // erkEstimateCreator
  // erkEstimateVerifier
  // erkSource
  // erkAppDev - Разработчик софта
  // erkCustom
  TEstRequisiteKind = (erkEstimateCreator, erkEstimateVerifier, erkSource, erkAppDev, erkCustom);
  /// Набор типов реквизитов
  TEstRequisiteKinds = set of TEstRequisiteKind;

  /// Запись, содержащая мета-информацию о файле со сметами
  TEstMetaInfo = record
  private
    FVersion: string;
    FSoft_Version: string;
    FSoft_Name: string;
    procedure SetSoft_Name(const Value: string);
    procedure SetSoft_Version(const Value: string);
    procedure SetVersion(const Value: string);
  public
    /// Версия формата файла
    property Version: string read FVersion write SetVersion;
    /// Наименование программного обеспечения используемого для создания файла
    property Soft_Name: string read FSoft_Name write SetSoft_Name;
    /// Версия программного обеспечения используемого для создания файла
    property Soft_Version: string read FSoft_Version write SetSoft_Version;
    /// Процедура очищает содержимое записи
    procedure Clear;
    /// Процедура заполняет запись информацией по умолчанию
    procedure Default;
  end;

  /// Запись для представления дат в сметных документах
  TEstimateDate = packed record
  private
    FYear, FMonth, FDay: Word;
    FNote: string;
    procedure SetDate(const Value: TDateTime);
    function GetDate: TDateTime;
    procedure SetNote(const Value: string);
  public
    /// Дата
    property Date: TDateTime read GetDate write SetDate;
    /// Год
    property Year: Word read FYear;
    /// Месяц (номер)
    property Month: Word read FMonth;
    /// День
    property Day: Word read FDay;
    /// Примечание
    property Note: string read FNote write SetNote;
    /// Конструктор, использующий календарную дату для инициализации записи
    constructor Create(const aDate: TDateTime); overload;
    /// Конструктор, использующий компоненты календарной даты (Год, Месяц, День) для инициализации записи
    constructor Create(const aYear, aMonth, aDay: Word); overload;
    /// Функция возвращает true, если запись содержит действительную дату
    function isValidDate: Boolean;
    function Quarter: Word;
  end;
  /// Указатель на запись для представления дат в сметных документах
  PEstimateDate = ^TEstimateDate;

  /// Сметная стоимость
  TEstimatePrice = packed record
  private
    Items: TEstimatePriceItems;
    function GetConstruction: Double;
    function GetEquipment: Double;
    function GetInstallation: Double;
    function GetItem(Index: TEstimatePriceItemType): Double;
    function GetMachines: Double;
    function GetMachinistSalary: Double;
    function GetMaterials: Double;
    function GetOther: Double;
    function GetOverhead: Double;
    function GetPrice: Double;
    function GetProfit: Double;
    function GetWorkersSalary: Double;
    procedure SetConstruction(const Value: Double);
    procedure SetEquipment(const Value: Double);
    procedure SetInstallation(const Value: Double);
    procedure SetItem(Index: TEstimatePriceItemType; const Value: Double);
    procedure SetMachines(const Value: Double);
    procedure SetMachinistSalary(const Value: Double);
    procedure SetMaterials(const Value: Double);
    procedure SetOther(const Value: Double);
    procedure SetOverhead(const Value: Double);
    procedure SetPrice(const Value: Double);
    procedure SetProfit(const Value: Double);
    procedure SetWorkersSalary(const Value: Double);
  public
    property Price: Double read GetPrice write SetPrice;
    property WorkersSalary: Double read GetWorkersSalary write SetWorkersSalary;
    property MachinistSalary: Double read GetMachinistSalary write SetMachinistSalary;
    property Overhead: Double read GetOverhead write SetOverhead;
    property Profit: Double read GetProfit write SetProfit;
    property Machines: Double read GetMachines write SetMachines;
    property Materials: Double read GetMaterials write SetMaterials;
    property Construction: Double read GetConstruction write SetConstruction;
    property Installation: Double read GetInstallation write SetInstallation;
    property Equipment: Double read GetEquipment write SetEquipment;
    property Other: Double read GetOther write SetOther;
    property Item[Index: TEstimatePriceItemType]: Double read GetItem write SetItem;
    constructor Create(const aPrice: Double);
    procedure Clear;
    function isNull: Boolean;
  end;

  /// Регион, в котором находится объект строительства
  TEstimateRegion = packed record
  private
    FRegionID: Word;
    FZoneID: Word;
    FIndustry: string;
    FRegionName: string;
    FRailwayName: string;
    FState: string;
    FZoneName: string;
    function GetZoneStr: string;
    function GetState: string;
    procedure SetIndustry(const Value: string);
    procedure SetRegionID(const Value: Word);
    procedure SetZoneID(const Value: Word);
    procedure SetZoneStr(const Value: string);
    procedure SetRegionName(const Value: string);
    procedure SetRailwayName(const Value: string);
    procedure SetState(const Value: string);
    procedure SetZoneName(const Value: string);
  public
    const
      RegionIDFieldName:    RawUTF8 = 'ri';
      RegionNameFieldName:  RawUTF8 = 'rn';
      ZoneIDFiledName:      RawUTF8 = 'zi';
      ZoneNameFiledName:    RawUTF8 = 'zn';
      RailwayNameFiledName: RawUTF8 = 'wn';
      IndustryFiledName:    RawUTF8 = 'in';
      StateFieldName:       RawUtf8 = 'st';
  public
    property Industry: string Read FIndustry write SetIndustry;
    /// Цифровой код субъекта РФ (региона)
    property RegionID: Word read FRegionID write SetRegionID;
    /// Наименование региона
    property RegionName: string Read FRegionName write SetRegionName;
    /// Наименование железной дороги
    property RailwayName: string read FRailwayName write SetRailwayName;
    property State: string read FState write SetState;
    /// Цифровой код идентифицирующий подрайон, ценовая зона в составе основного региона (Субъект РФ), в котором расположен объект строительства
    property ZoneID: Word read FZoneID write SetZoneID;
    /// Наименование ценовой зоны
    property ZoneName: string read FZoneName write SetZoneName;
    /// Строка идентифицирующая подрайон, ценовая зона в составе основного региона (Субъект РФ), в котором расположен объект строительства
    property ZoneStr: string read GetZoneStr write SetZoneStr;
    /// Конструктор инициализирующий запись идентификорами региона (aID) и зоны (aZone)
    constructor Create(const aID: Word; const aZone: Word=0); overload;
    /// Конструктор инициализирующий запись информацией из JSON-документа
    constructor Create(const V: Variant); overload;
    /// Конструктор инициализирующий запись информацией из JSON-документа
    constructor Create(const P: PDocVariantData); overload;
    /// Функция определяет  идентификатор региона по его наименованию, используя список регионов РФ,
    // хранящийся в ресурсах программы или в файле
    class function RegionIDByName(const RName: string; const Region: string;
                                  const FromResource: Boolean=True): Integer; static;
    class function RegionNameByID(const RName: string; const Region: Word;
                                  const FromResource: Boolean=True): string; static;
    class function Utf8RegionNameByID(const RName: RawUtf8; const Region: Word;
                                      const FromResource: Boolean=True): RawUtf8; static;
    class function RailwayZoneNameByID(const RName: string; const Zone,Subzone: Word;
                                const FromResource: Boolean=True): string; static;
    /// Функция возвращает строку из RZD_ZONES
    class function RailwayZoneStr(const RName: string; const Zone,Subzone: Word;
                                  const FromResource: Boolean=True): string; static;
    /// Функция возвращает строку из RZD_ZONES
    class function RailwayZoneUTF8(const RName: string; const Zone,Subzone: Word;
                                   const FromResource: Boolean=True): RawUtf8; static;
    /// Процедура очищает запись
    procedure Clear;
    function FromStr(const Txt: string): Boolean;
    function IndustryName: string;
    /// функция корректирует информацию о ценовой зоне РЖД, используя строку из RZD_ZONES
    function PatchRailwayZoneFromUtf8(const Txt: RawUtf8): Boolean;
    /// функция корректирует информацию о ценовой зоне РЖД используя ресурсы
    // Предварительно информация о ценовой зоне РЖД уже получена из сметы (BASES_ZONES и CAPTION)
    function PatchRailwayZone: Boolean;
    /// функция корректирует информацию об идентификаторе ценовой зоны РЖД используя ресурсы
    function PatchRailwayZoneID: Boolean;
    /// Функция загружает JSON-документ с информацией о регионе
    function FromDoc(const PDoc: PDocVariantData): Boolean;
    /// Функция формирует JSON-документ с информацией о регионе
    function ToDoc: Variant;
  end;

  TEstimateExpense = record
  private
    FName: string;
    FOperationType: TEstimateOperationType;
    FReason: string;
    FValue: Double;
    procedure SetName(const Value: string);
    procedure SetOperationType(const Value: TEstimateOperationType);
    procedure SetReason(const Value: string);
    procedure SetValue(const Value: Double);
  public
    property Reason: string read FReason write SetReason;
    property Name: string read FName write SetName;
    property Value: Double read FValue write SetValue;
    property OperationType: TEstimateOperationType read FOperationType write SetOperationType;
    constructor Create(const aReason, aName: string; const aValue: Double; const aOpType:TEstimateOperationType=eopSum);
  end;
  PEstimateExpense = ^TEstimateExpense;
  TEstimateExpenses = array of TEstimateExpense;

  /// Виды затрат, учтенные в сметной цене материальных ресурсов или оборудования
  // extShippingContainer    - Тара, упаковка, реквизит (пункт 88 Методики)
  // extSparePartKit         - Стоимость комплекта запасных частей (пункт 88 Методики)
  // extSupplyMargins        - Снабженческие наценки (пункт 88 Методики)
  // extPaymentOfDuties      - Расходы на уплату пошлин (пункт 88 Методики)
  // extTaxExpense           - Расходы на уплату налогов (пункт 88 Методики)
  // extPaymentOfFees        - Расходы на уплату сборов (пункт 88 Методики)
  // extOtherCustomsPayments - Другие таможенные платежи (пункт 88 Методики)
  // extContractSupervision  - Шефмонтаж (подпункт 'а' пункта 117 Методики)
  // extChiefAdjustment      - Шефналадка (подпункт 'а' пункта 117 Методики)
  // extCalibration          - Доводка (калибровка) (подпункт 'б' пункта 117 Методики)
  // extFinishing            - Доизготовление (подпункт 'в' пункта 117 Методики)
  // extSpecialTooling       - Изготовление специальной оснастки (подпункт 'г' пункта 117 Методики)
  // extPreInstalledSoftware - Предварительно установленное программное обеспечение (подпункт 'д' пункта 117 Методики)
  // extEquipmentConformity  - Затраты по оценке соответствия оборудования (подпункт 'е' пункта 117 Методики)
  // extOtherCosts           - Другие затраты (подпункт 'ж' пункта 117 Методики)
  // extEquipmentPackage     - Комплектация оборудования (пункт 119 Методики)
  TEstimateExpenseType = (extShippingContainer, extSparePartKit, extSupplyMargins, extPaymentOfDuties, extTaxExpense,
                          extPaymentOfFees, extOtherCustomsPayments, extContractSupervision, extChiefAdjustment,
                          extCalibration, extFinishing, extSpecialTooling, extPreInstalledSoftware,
                          extEquipmentConformity, extOtherCosts, extEquipmentPackage,
                          extUndefine);
  TEstimateExpenseTypes = set of TEstimateExpenseType;

  /// Вид франко
  //edtAccounted   - с учетом затрат на перевозку до приобъектного склада
  //edtAccountedEx - с учетом затрат на перевозку до промежуточной точки по маршруту перевозки,
  //                 когда требуется включение затрат на перевозку до приобъектного склада по расчету дополнительно
  //edtUnaccounted - без учета затрат на перевозку
  TEstimateDeliveryTerm = (edtAccounted, edtAccountedEx, edtUnaccounted, edtUndefined);
  TEstimateDeliveryTerms = set of TEstimateDeliveryTerm;

  /// Тип уровня цен
  // epltBase
  // epltCur
  // epltNone
  TEstimatePriceLevelType = (epltBase, epltCur, epltNone);

  /// Виды строительных объектов
  // Объект капитального строительства непроизводственного назначения - eokNonIndustrial  - eokNonProduction
  // Объект капитального строительства производственного назначения - eokIndustrial       - eokProduction
  // Объект капитального строительства производственного и непроизводственного назначения - eokProdNonProd
  // Линейный объект - eokLinear
  // Уникальный, особо опасный и технически сложный объект капительного строительства     - eokDangerous
  TEstimateObjectKind = (eokNonIndustrial, eokIndustrial, eokLinear,
                         eokProduction, eokNonProduction, eokProdNonProd, eokDangerous);
  TEsttimateObjectKinds = set of TEstimateObjectKind;

  /// Категория помещений, зданий и наружных установок по взрывопожарной и пожарной опасности
  //<xs:enumeration value="А"/>
  //<xs:enumeration value="Б"/>
  //<xs:enumeration value="В"/>
  //<xs:enumeration value="Г"/>
  //<xs:enumeration value="Д"/>
  //<xs:enumeration value="Категория не устанавливается"/>
  TFireDangerCategory = (fdcA, fdcB, fdcV, fdcG, fdcD, fdcU, fdcUndefined);
  TFireDangerCategories = set of TFireDangerCategory;

  /// Уровень ответственности здания или сооружения
  // erlRaised  - "повышенный"
  // erlNormal  - "нормальный"
  // erlLowered - "пониженный"
  TEstResponsibilityLevel =(erlRaised, erlNormal, erlLowered, erlUndefined);
  TEstResponsibilityLevels = set of TEstResponsibilityLevel;

  /// Уровень бюджета
  // eblFederal        - "Федеральный бюджет"
  // eblRegional       - "Бюджет субъекта Российской Федерации"
  // eblLocal          - "Местный бюджет"
  // eblStateNBF       - "Бюджет государственного внебюджетного фонда Российской Федерации"  state non-budgetary fund
  // eblTerritorialNBF - "Бюджет территориального государственного внебюджетного фонда"

  TEstBudgetLevel = (eblFederal, eblRegional, eblLocal, eblStateNBF, eblTerritorialNBF, eblUndefined);

  /// Уровень цен сметы
  TEstimatePriceLevel = packed record
  private
    FNote, FDescription: string;
    FNormOverdraft, FNormProfit: Double;
    FYear, FMonth, FDay: Word;
    procedure SetDate(const Value: TDateTime);
    function GetDate: TDateTime;
    procedure SetDescription(const Value: string);
    procedure SetNormOverdraft(const Value: Double);
    procedure SetNormProfit(const Value: Double);
    procedure SetNote(const Value: string);
  public
    property Date: TDateTime read GetDate write SetDate;
    property Note: string read FNote write SetNote;
    property Year: Word read FYear;
    property Month: Word read FMonth;
    property Day: Word read FDay;
    property Description: string read FDescription write SetDescription;
    property NormOverdraft: Double read FNormOverdraft write SetNormOverdraft;
    property NormProfit: Double read FNormProfit write SetNormProfit;
    constructor Create(const aDate: TDateTime; const aNote: string=''); overload;
    constructor Create(const aYear, aMonth, aDay: Word; const aNote: string=''); overload;
    constructor Create(const aStr: string); overload;
    function FromDoc(pDoc: PDocVariantData): Boolean;
    function ToDoc: Variant;
    function ToText(const Quarter: Boolean): string;
    function ToDateStr(const Sep: AnsiChar='.'): string;
    /// функция вовращает строку с указанием уровня цен в формате "MM/YY" или "MMYY", если флаг Sep не установлен
    function PLText(const Sep: Boolean=True): string; inline;
    function DateFromStr(const aStr: string): Boolean;
    function Quarter: Integer;
    /// функция из строки вида "MM/YY XXXXX" возврашает XXXXX - автора сборника индексов (текст за пробелом)
    function IdxAuthorTS(const aStr: string): string;
    function IdxAuthorTSUtf8(const aTxt: RawUtf8): RawUtf8;
  end;
  PEstimatePriceLevel = ^TEstimatePriceLevel;
var
  PriceLevel2000, PriceLevel2000MNB: TEstimatePriceLevel;
  PriceLevel2001: TEstimatePriceLevel;
  PriceLevel2022: TEstimatePriceLevel;
  PriceLevelZero: TEstimatePriceLevel;

type
  /// Значение коэффициета применяемого к элементу стоимости
  TEstimateCoefValue = record
  public
    /// Значение коэффициета, применяемого к элементу стоимости
    Value: Double;
    /// Элемент стоимости к которому применяется
    Target: TEstimateValueTarget;
    /// Операция выполняемая с применением коэффициента
    Operation: TEstimateOperationType;
    /// Конструктор
    constructor Create(const aValue: Double; const aTarget: TEstimateValueTarget;
                       const aOperation: TEstimateOperationType=eopMul);
    /// Возварщает true, если значение коэффициента равно 0
    function IsZero: Boolean;
    /// Возварщает true, если значение коэффициента равно 1
    function IsOne: Boolean;
    class function TargetAsRawUTF8(const ValueTarget: TEstimateValueTarget): RawUtf8; static;
    class function TargetAsString(const ValueTarget: TEstimateValueTarget): string; static;
    class function StringAsTarget(const Str: string): TEstimateValueTarget; static;
  end;
  PEstimateCoefValue = ^TEstimateCoefValue;
  TEstimateCoefValues = array of TEstimateCoefValue;

  /// Коэффициент
  TEstimateCoefficient = record
  private
    FName: string;
    FNum: Byte;
    FToNum: Byte;
    FReason: string;
    FOperaion: TEstimateOperationType;
    FValue: Double;
    procedure SetName(const NewValue: string);
    procedure SetNum(const NewValue: Byte);
    procedure SetOperaion(const NewValue: TEstimateOperationType);
    procedure SetReason(const NewValue: string);
    procedure SetToNum(const NewValue: Byte);
    procedure SetValue(const NewValue: Double);
  public
    /// Наименование
    property Name: string read FName write SetName;
    /// Обоснование
    property Reason: string read FReason write SetReason;
    /// Порядковый номер в списке коэффициентов
    property Num: Byte read FNum write SetNum;
    /// Номер коэффициента, к оторому должен быть применён коэффициент
    property ToNum: Byte read FToNum write SetToNum;
    /// Тип операции для применения коэффициента
    property Operaion: TEstimateOperationType read FOperaion write SetOperaion;
    /// Величина коэффициента
    property Value: Double read FValue write SetValue;
    /// конструктор
    constructor Create(const aName: string; const aValue: Double; const aOp: TEstimateOperationType = eopMul; const aToNum: Byte=0);
    /// Функция возвращает true, если коэффициент нулевой
    function isNull: Boolean;
  end;
//  PEstCoefficient = ^TEstimateCoefficient;
//  TEstCoefficients = array of TEstimateCoefficient;

  /// Стоимость позиции(расценки)
  TEstPositionPrice = record
  private
    Items: TEstPositionPriceItems;
    function GetItem(Index: TEstPositionPriceItemType): Double;
    procedure SetItem(Index: TEstPositionPriceItemType; const Value: Double);
    function GetPrice: Double;
  public
    property Item[Index: TEstPositionPriceItemType]: Double read GetItem write SetItem;
    property Price: Double read GetPrice;
    constructor Create(const aPrice: Double); overload;
    constructor Create(const aWorker, aMachines, aMachinist, aMaterials: Double); overload;
    procedure Clear;
    function isNull: Boolean;
    function isDirectOnly: Boolean;
  end;
  PEstPositionPrice = ^TEstPositionPrice;

  /// Затраты труда учтённые в позиции
  TEstPositionLaborCost = record
  private
    Items: TEstPositionLaborItems;
    function GetItem(Index: TEstPositionLaborItemType): Double;
    procedure SetItem(Index: TEstPositionLaborItemType; const Value: Double);
  public
    property Item[Index: TEstPositionLaborItemType]: Double read GetItem write SetItem;
    constructor Create(const aWorker, aMachinist: Double);
    procedure Clear;
    function isNull: Boolean;
  end;
  PEstPositionLaborCost = ^TEstPositionLaborCost;

  PEstLinkResource= ^TEstLinkResource;
  TEstLinkResource = packed record
  private
    FGuid: TGUID;
    FID: Cardinal;
    procedure SetGuid(const AValue: TGUID);
    procedure SetID(const AValue: Cardinal);
  public
    property GUID: TGUID read FGuid write SetGuid;
    property ID: Cardinal read FID write SetID;
    procedure Init(const AID: Cardinal=0); overload;
    procedure Init(const AGuid: TGUID; const AID: Cardinal); overload;
    function IsEqual(const LR: TEstLinkResource): Boolean; inline;
    procedure From(LR: TEstLinkResource);
    function ToDoc: Variant;
    function FromDoc(const PDoc: PDocVariantData): Boolean;
  end;
  TEstLinkResourceDynArray = array of TEstLinkResource;

  /// Подпись
  TEstSignature = record
  private
    FCode: TEstJobCode;
    FFIO: string;
    FJob: string;
    function GetEmpty: Boolean;
    procedure SetCode(const Value: TEstJobCode);
    procedure SetEmpty(const Value: Boolean);
    procedure SetFIO(const Value: string);
    procedure SetJob(const Value: string);
  public
    /// Цифровой код
    property Code: TEstJobCode read FCode write SetCode;
    /// Признак отсутствия данных
    property Empty: Boolean read GetEmpty write SetEmpty;
    /// ФИО подписанта
    property FIO: string read FFIO write SetFIO;
    /// Должность подписанта
    property Job: string read FJob write SetJob;
    /// Конструктор
    constructor Create(const aCode: TEstJobCode; const aFIO: string; const aPost: string=''); overload;
    /// Конструктор
    constructor Create(const PDoc: PDocVariantData); overload;
    /// Процедура очищает информацию
    procedure Clear;
    /// процедура копирует содержимое из другой подписи
    procedure CopyFrom(Src: TEstSignature);
    /// Функция загружает информацию из JSON-документа
    function FromDoc(const Json: RawUtf8): Boolean; overload;
    /// Функция загружает информацию из JSON-документа
    function FromDoc(const PDoc: PDocVariantData): Boolean; overload;
    /// Функция возвращает JSON-документ с информацией о подписи
    function ToDoc: Variant;
  end;
  PEstSignature = ^TEstSignature;
  TEstSignatures = array of TEstSignature;

  TEstTotalPriceItem = record
  private
    FPrice: Double;
    FNameIdx: Integer;
    function GetNameIdx: Integer;
    procedure SetName(const Value: string);
    procedure SetPrice(const Value: Double);
    function GetName: string;
  public
    property Name: string read GetName write SetName;
    property NameIdx: Integer read GetNameIdx;
    property Price: Double read FPrice write SetPrice;
    constructor Create(const aName: string; aPrice: Double = 0.00);
  end;

/// Наименование корпорации или принадлежности к отрасли.
// eiAlrosa      - АКЦИОНЕРНАЯ КОМПАНИЯ "АЛРОСА" (ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО)          – АЛР
// eiRailways    - ОТКРЫТОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "РОССИЙСКИЕ ЖЕЛЕЗНЫЕ ДОРОГИ"              - РЖД
// eiRosseti     - ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "ФЕДЕРАЛЬНАЯ СЕТЕВАЯ КОМПАНИЯ - РОССЕТИ" - РСС
// eiRosatom     - ГОСУДАРСТВЕННАЯ КОРПОРАЦИЯ ПО АТОМНОЙ ЭНЕРГИИ "РОСАТОМ"                 – РСТ
// eiTransneft   - ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "ТРАНСНЕФТЬ"                             – ТРН
// eiMinPromTorg - МИНИСТЕРСТВО ПРОМЫШЛЕННОСТИ И ТОРГОВЛИ РОССИЙСКОЙ ФЕДЕРАЦИИ             - МПТ
// eiMinTrans    - МИНИСТЕРСТВО ТРАНСПОРТА РОССИЙСКОЙ ФЕДЕРАЦИИ                            - МТР
// eiMinOboron   - МИНИСТЕРСТВО ОБОРОНЫ РОССИЙСКОЙ ФЕДЕРАЦИИ                               - МНБ

// eiOther                                                                               - ПРОЧЕЕ
// eiUndefine
  TEstIndustry = (eiAlrosa, eiRailways, eiRosseti, eiRosatom, eiTransneft, eiMinPromTorg, eiMinTrans, eiMinOboron,
  eiOther, eiUndefine);
  TEstIndustries = set of TEstIndustry;


const
  /// Отраслевые корпорации
  EstIndustriesCorp: TEstIndustries = [eiAlrosa, eiRailways, eiRosseti, eiRosatom, eiTransneft];
  EstIndustriesGov: TEstIndustries = [eiMinPromTorg, eiMinTrans, eiMinOboron];
  EstIndustriesAll: TEstIndustries = [eiAlrosa, eiRailways, eiRosseti, eiRosatom, eiTransneft,
                                      eiMinPromTorg, eiMinTrans, eiMinOboron];

function EstIndustryToText(const ei: TEstIndustry): string;
function EstIndustryToCode(const ei: TEstIndustry): string;
function EstIndustryToTextU(const ei: TEstIndustry): RawUtf8;
function EstIndustryToCodeU(const ei: TEstIndustry): RawUtf8;
function EstIndustryFromUtf8(const r: RawUtf8): TEstIndustry;
function EstIndustryFromStr(const r: string): TEstIndustry;

const
  Sig_Composer = 1;
  Sig_Veifier  = 2;

  /// стоп символы для префикса шифра
  EstCypherPrefixStopChars: array[0..12] of Char = (' ','1','2','3','4','5','6','7','8','9','0','-','_');

  EstSecChapterNames: array[0..13] of string = (
    'Подготовка территории строительства, реконструкции, капитального ремонта',
    'Основные объекты строительства, реконструкции, капитального ремонта',
    'Объекты подсобного и обслуживающего назначения',
    'Объекты энергетического хозяйства',
    'Объекты транспортного хозяйства и связи',
    'Наружные сети и сооружения водоснабжения, водоотведения, теплоснабжения и газоснабжения',
    'Благоустройство и озеленение территории',
    'Временные здания и сооружения',
    'Прочие работы и затраты',
    'Содержание службы заказчика. Строительный контроль',
    'Подготовка эксплуатационных кадров для строящегося объекта капитального строительства',
    'Публичный технологический и ценовой аудит, подготовка обоснования инвестиций, ' +
    'осуществляемых в инвестиционный проект по созданию объекта капитального строительства, ' +
    'в отношении которого планируется заключение контракта, предметом которого является одновременно ' +
    'выполнение работ по проектированию, строительству и вводу в эксплуатацию объекта капитального строительства, ' +
    'технологический и ценовой аудит такого обоснования инвестиций, аудит проектной документации, проектные и изыскательские работы',
    'Непредвиденные работы и затраты',
    'Налоги и обязательные платежи'
                      );
var
  EstCoefficientNull: TEstimateCoefficient;
  EstCoefValueNull: TEstimateCoefValue;
  DefaultMeta: TEstMetaInfo;
  BExpert_Build: Integer;
  /// Установки форматов
  EstimateFormatSettings: TFormatSettings;
  /// Дельта для сравнения цен
  EstimatePriceDeltaZero: Double;
  /// Дельта для сравнения вещественных значений
  EstimateValueDeltaZero: Double;
  /// Точность представления значения цены
  EstimatePricePrecision: Byte;
  /// Точность представления  значения объёма
  EstimateQuantityPrecision: Byte;
  /// Точность представления вещественного значения
  EstimateValuePrecision: Byte;

/// Функция возвращае true, если значение цены приблизительно равно нулю
function EstPriceIsZero(const Value: Double): Boolean; inline;
/// Функция возвращае true, если значение приблизительно равно единице
function EstValueIsOne(const Value: Double): Boolean; inline;
/// Функция возвращае true, если значение приблизительно равно нулю
function EstValueIsZero(const Value: Double): Boolean; inline;

/// Функция конвертирует вещественное число в строку с заданным количеством знаков
// после десятичного разделителя
function EstDoubleToString(const D: Double; const Prec: Integer): string; inline;
/// Функция конвертирует вещественное число в строку с заданным количеством знаков
// после десятичного разделителя
function EstDoubleToUTF8(const D: Double; const Prec: Integer): RawUTF8; inline;

function EstimateOperationTypeToAnsiChar(const Op: TEstimateOperationType): AnsiChar;
function EstimateOperationTypeToChar(const Op: TEstimateOperationType): Char;
function EstimatePriceLevelTypeToUTF8(const PL: TEstimatePriceLevelType): RawUTF8;
function EstimatePriceLevelTypeToString(const PL: TEstimatePriceLevelType): string;
function EstimatePriceLevelFromStr(const S: string; out PriceLevel: TEstimatePriceLevelType): boolean;
function EstOperationTypeFromChar(const Op: Char): TEstimateOperationType; overload;
function EstOperationTypeFromChar(const Op: Char; out OpeationType: TEstimateOperationType): boolean; overload;
function EstimateIndexTypeToString(const it: TEstimateIndexType): string;
function EstimateIndexTypeFromString(const it: string):TEstimateIndexType;
function EstimateNormativeTypeFromString(const nt: string): TEstimateNormativeType;
function EstimateNormativeTypeToString(const nt: TEstimateNormativeType): string;

/// функция проверяет что строка начинается с обозначение типа позиции
function EstCheckPositionTypeName(const aStr: string; out oPosType: TEstimatePositionType): Boolean;
function EstCheckPositionTypeNameU(const aStr: RawUtf8; out oPosType: TEstimatePositionType): Boolean;
function EstFederalAuthor(const Author: string): Boolean;
function EstPositionEquipmentPrefix(const Cypher, Author: string; BaseMethodic: TEstimateBaseMethodic): TEstimatePositionType;
function EstPositionMateialPrefix(const Cypher, Author: string; BaseMethodic: TEstimateBaseMethodic): TEstimatePositionType;

/// функция конверирует строку в тип ресурса
function EstResTypeFromStr(const S: string; out ResType: TEstimateResourceType): Boolean;

/// Функция разбивает шифр на префикс и код
function EstPositionSplitCypher(const Cypher: string; out Prfx: string; out Code: string): Boolean;

function DocTypeFromText(const edt: RawUtf8): TEstDocType;
function DocTypeToText(const edt: TEstDocType): RawUtf8;

implementation

var
  TotalPriceItemNames: TStringDynArray;


function EstIndustryFromStr(const r: string): TEstIndustry;
begin
  if      r=rus_ALR    then Result:=eiAlrosa
  else if r=rus_RZD    then Result:=eiRailways
  else if r=rus_RSS    then Result:=eiRosseti
  else if r=rus_RST    then Result:=eiRosatom
  else if r=rus_TRN    then Result:=eiTransneft
  else if r=rus_MPT    then Result:=eiMinPromTorg
  else if r=rus_MTR    then Result:=eiMinTrans
  else if r=rus_MNB    then Result:=eiMinOboron
  else if r=rus_OTR    then Result:=eiOther
  else                      Result:=eiUndefine
end;

function EstIndustryFromUtf8(const r: RawUtf8): TEstIndustry;
begin
  if      r=StringToUtf8(rus_ALR)    then Result:=eiAlrosa
  else if r=StringToUtf8(rus_RZD)    then Result:=eiRailways
  else if r=StringToUtf8(rus_RSS)    then Result:=eiRosseti
  else if r=StringToUtf8(rus_RST)    then Result:=eiRosatom
  else if r=StringToUtf8(rus_TRN)    then Result:=eiTransneft
  else if r=StringToUtf8(rus_MPT)    then Result:=eiMinPromTorg
  else if r=StringToUtf8(rus_MTR)    then Result:=eiMinTrans
  else if r=StringToUtf8(rus_MNB)    then Result:=eiMinOboron
  else if r=StringToUtf8(rus_OTR)    then Result:=eiOther
  else                                    Result:=eiUndefine
end;

function EstIndustryToCode(const ei: TEstIndustry): string;
begin
  case ei of
    eiAlrosa:      Result:=rus_ALR;
    eiRailways:    Result:=rus_RZD;
    eiRosseti:     Result:=rus_RSS;
    eiRosatom:     Result:=rus_RST;
    eiTransneft:   Result:=rus_TRN;
    eiMinPromTorg: Result:=rus_MPT;
    eiMinTrans:    Result:=rus_MTR;
    eiMinOboron:   Result:=rus_MNB;
    eiOther:       Result:=rus_OTR;
    eiUndefine:    Result:='';
  end;
end;
function EstIndustryToCodeU(const ei: TEstIndustry): RawUtf8;
begin
  Result:=StringToUtf8(EstIndustryToCode(ei));
end;
function EstIndustryToText(const ei: TEstIndustry): string;
begin
  case ei of
    eiAlrosa:      Result:=rusName_ALR; //'АКЦИОНЕРНАЯ КОМПАНИЯ "АЛРОСА" (ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО)';
    eiRailways:    Result:=rusName_RZD; //'ОТКРЫТОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "РОССИЙСКИЕ ЖЕЛЕЗНЫЕ ДОРОГИ"';
    eiRosseti:     Result:=rusName_RSS; //'ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "ФЕДЕРАЛЬНАЯ СЕТЕВАЯ КОМПАНИЯ - РОССЕТИ"';
    eiRosatom:     Result:=rusName_RST; //'ГОСУДАРСТВЕННАЯ КОРПОРАЦИЯ ПО АТОМНОЙ ЭНЕРГИИ "РОСАТОМ"';
    eiTransneft:   Result:=rusName_TRN; //'ПУБЛИЧНОЕ АКЦИОНЕРНОЕ ОБЩЕСТВО "ТРАНСНЕФТЬ"';
    eiMinPromTorg: Result:=rusName_MPT; //'МИНИСТЕРСТВО ПРОМЫШЛЕННОСТИ И ТОРГОВЛИ РОССИЙСКОЙ ФЕДЕРАЦИИ';
    eiMinTrans:    Result:=rusName_MTR; //'МИНИСТЕРСТВО ТРАНСПОРТА РОССИЙСКОЙ ФЕДЕРАЦИИ';
    eiMinOboron:   Result:=rusName_MNB; //'МИНИСТЕРСТВО ОБОРОНЫ РОССИЙСКОЙ ФЕДЕРАЦИИ';
    eiOther:       Result:='';
    eiUndefine:    Result:='';
  end;
end;
function EstIndustryToTextU(const ei: TEstIndustry): RawUtf8;
begin
  Result:=StringToUtf8(EstIndustryToText(ei));
end;

function EstFederalAuthor(const Author: string): Boolean;
begin
  if Author='' then Result:=True
  else begin

  end;
end;

function EstPositionSplitCypher(const Cypher: string; out Prfx: string; out Code: string): Boolean;
var i: integer;
begin
  Prfx:=''; Code:='';
  for i := 1 to Length(Cypher) do
{$IFDEF DELPHIXE2}
    if CharInSet(Cypher[i], ['0'..'1']) then begin
{$ELSE}
    if Cypher[i] in ['0'..'1'] then begin
{$ENDIF}
      if i>1 then prfx := DBDTrim(Copy(Cypher, 1, i-1))
             else Code := Cypher;
      Break;
    end;
  if Prfx='' then Result := (Code<>'')
  else begin
    Code := DBDTrim(Copy(Cypher, Length(Prfx)+1, Length(Cypher)-Length(Prfx)));
    Result := True;
  end;
end;

function EstPositionEquipmentPrefix(const Cypher, Author: string; BaseMethodic: TEstimateBaseMethodic): TEstimatePositionType;
begin
//  EstimatePositionsEquipments: TEstimatesPositionTypes = [eptFSSC, eptTSSC, eptOSCGo, eptPriceEqu];

  if not EstCheckPositionTypeName(Cypher, Result) then begin
    Result := eptPriceEqu;
  end;

end;
function EstPositionMateialPrefix(const Cypher, Author: string; BaseMethodic: TEstimateBaseMethodic): TEstimatePositionType;
begin
//  EstimatePositionsMaterials: TEstimatesPositionTypes = [eptFSSC, eptTSSC, eptOSSCG, eptPriceMat];
  if not EstCheckPositionTypeName(Cypher, Result) then begin
    Result := eptPriceMat;
  end;
end;

function EstCheckPositionTypeName(const aStr: string; out oPosType: TEstimatePositionType): Boolean;
var i: TEstimatePositionType; s,sa: string;
begin
  Result:=True;
  sa:=DBDToUpper(aStr);
  for i := Low(TEstimatePositionType) to High(TEstimatePositionType) do begin
    s:=DBDToUpper(EstPositionTypeNames[i]);
    if sa=s then begin
      oPosType := i; Exit;
    end;
  end;
  if      sa=DBDToUpper(rusFERa) then oPosType := eptFSSCpg
  else if sa=DBDToUpper(rusTERa) then oPosType := eptTSSCpg
  else Result:=False;
end;
function EstCheckPositionTypeNameU(const aStr: RawUtf8; out oPosType: TEstimatePositionType): Boolean;
var i: TEstimatePositionType;
begin
  Result:=True;
  for i := Low(TEstimatePositionType) to High(TEstimatePositionType) do begin
    if aStr=EstPositionTypeNamesUTF8[i] then begin
      oPosType := i; Exit;
    end;
  end;
  if      aStr=StringToUtf8(rusFERa) then oPosType := eptFSSCpg
  else if aStr=StringToUtf8(rusTERa) then oPosType := eptTSSCpg
  else Result:=False;
end;

function EstDoubleToString(const D: Double; const Prec: Integer): string;
begin
  if D=0.00 then Result := '0'
  else begin
    Result := FloatToStrF(D, ffFixed, EST_DOUBLE_PRECISION, Prec, EstimateFormatSettings);
    Result := DBDTrimChar(Result,'0', dbdSPRight);
  end;
end;

function EstDoubleToUTF8(const D: Double; const Prec: Integer): RawUTF8;
begin
  Result := StringToUTF8(FloatToStrF(D, ffFixed, EST_DOUBLE_PRECISION, Prec, EstimateFormatSettings));
end;

function EstimateIndexTypeFromString(const it: string):TEstimateIndexType;
begin
  if      it='Отсутствует'                                 then Result:=eitNone
  else if it='Индексы к СМР'                               then Result:=eitUnified
  else if it='Индексы к элементам прямых затрат'           then Result:=eitCosts
  else if it='Индексы к элементам прямых затрат в позиции' then Result:=eitItems
  else if it='Работы'                                      then Result:=eitWorks
  else                                                          Result:=eitNone
end;
function EstimateIndexTypeToString(const it: TEstimateIndexType): string;
begin
  case it of
    eitNone:    Result:='Отсутствует';
    eitUnified: Result:='Индексы к СМР';
    eitCosts:   Result:='Индексы к элементам прямых затрат';
    eitWorks:   Result:='Работы';
    eitItems:   Result:='Индексы к элементам прямых затрат в позиции';
    else        Result:='Отсутствует';
  end;
end;

function EstimateNormativeTypeFromString(const nt: string): TEstimateNormativeType;
begin
  if      nt='ГСН' then Result:=entGSN
  else if nt='ОСН' then Result:=entOSN
  else if nt='ТЕР' then Result:=entTER
  else if nt='ИСН' then Result:=entISN
  else if nt='Справочная информация' then Result:=entRef
  else                  Result:=entUndefine;
end;
function EstimateNormativeTypeToString(const nt: TEstimateNormativeType): string;
begin
  case nt of
    entGSN: Result:='ГСН';
    entOSN: Result:='ОСН';
    entTER: Result:='ТЕР';
    entISN: Result:='ИСН';
    entRef: Result:='Справочная информация';
    else    Result:='';
  end;
end;

function EstimatePriceLevelTypeToString(const PL: TEstimatePriceLevelType): string;
begin
  case PL of
    epltBase: Result := 'Base';
    epltCur: Result := 'Cur';
    epltNone: Result := '';
  end;
end;

function EstimatePriceLevelTypeToUTF8(const PL: TEstimatePriceLevelType): RawUTF8;
begin
  Result := StringToUTF8(EstimatePriceLevelTypeToString(PL));
end;

function EstPriceIsZero(const Value: Double): Boolean;
begin
  Result := (Value<EstimatePriceDeltaZero) and (Value>(-EstimatePriceDeltaZero));
end;
function EstValueIsOne(const Value: Double): Boolean;
begin
  Result := ((Value-1)<EstimateValueDeltaZero) and ((Value-1)>(-EstimateValueDeltaZero));;
end;
function EstValueIsZero(const Value: Double): Boolean;
begin
  Result := (Value<EstimateValueDeltaZero) and (Value>(-EstimateValueDeltaZero));
end;

function EstOperationTypeFromChar(const Op: Char): TEstimateOperationType;
begin
  Result := eopMul;
  case Op of
    '*': Result := eopMul;
    '+': Result := eopSum;
    '-': Result := eopSub;
    '/': Result := eopDiv;
  end;
end;
function EstOperationTypeFromChar(const Op: Char; out OpeationType: TEstimateOperationType): boolean; overload;
begin
   Result := True;
  case Op of
    '*': OpeationType := eopMul;
    '+': OpeationType := eopSum;
    '-': OpeationType := eopSub;
    '/': OpeationType := eopDiv;
    else Result := False;
  end;
end;
function EstimateOperationTypeToAnsiChar(const Op: TEstimateOperationType): AnsiChar;
begin
  Result := '*';
  case Op of
    eopMul: Result := '*';
    eopSum: Result := '+';
    eopSub: Result := '-';
    eopDiv: Result := '/';
  end;
end;
function EstimateOperationTypeToChar(const Op: TEstimateOperationType): Char;
begin
  Result := '*';
  case Op of
    eopMul: Result := '*';
    eopSum: Result := '+';
    eopSub: Result := '-';
    eopDiv: Result := '/';
  end;
end;
function EstimatePriceLevelFromStr(const S: string; out PriceLevel: TEstimatePriceLevelType): boolean;
begin
  Result := True; PriceLevel := epltNone;
  if      S='Base' then PriceLevel:=epltBase
  else if S='Cur'  then PriceLevel:=epltCur
  else Result := False;
end;
function EstValueTargetFromStr(const S: string; out Trg: TEstimateValueTarget): boolean;
var i: TEstimateValueTarget;
begin
  Result := True;
  for i:= Low(TEstimateValueTarget) to High(TEstimateValueTarget) do
    if EstValueTargetNames[i]=S then begin Trg:=i; Exit; end;
  Result := False;
end;
function EstValueTargetFromPriceItem(const epi: TEstimatePriceItemType): TEstimateValueTarget;
begin
  case epi of
    epiPrice:           Result:=evtDirect;
    epiDirect:          Result:=evtDirect;
    epiTotalPrice:      Result:=evtDirect;
    epiTotalWithSubs:   Result:=evtDirect;
    epiWorkersSalary:   Result:=evtWorkerSalary;
    epiMachinistSalary: Result:=evtMachinistSalary;
    epiSalary:          Result:=evtWageFund;
    epiMachines:        Result:=evtMachines;
    epiMaterial:        Result:=evtMaterial;
    epiConstruction:    Result:=evtDirect;
    epiInstallation:    Result:=evtDirect;
    epiRestoration:     Result:=evtDirect;
    epiRepair:          Result:=evtDirect;
    epiStartup:         Result:=evtStartUp;
    epiEquipment:       Result:=evtEquipment;
    epiEquipmentNotENB: Result:=evtEquipment;
    epiMaterialNotENB:  Result:=evtMaterial;
    epiPortage:         Result:=evtPortage;
    epiPortageCnstr:    Result:=evtPortage;
    epiPortageInstl:    Result:=evtPortage;
    epiPortageEqmnt:    Result:=evtPortage;
    epiWarehouse:       Result:=evtNone;
    epiOther:           Result:=evtNone;
    epiOverhead:        Result:=evtNone;
    epiOverheadWorkSalary: Result:=evtNone;
    epiOverheadMachSalary: Result:=evtNone;
    epiProfit:             Result:=evtNone;
    epiProfitWorkSalary:   Result:=evtNone;
    epiProfitMachSalary:   Result:=evtNone;
    epiOPWorkSalary:       Result:=evtNone;
    epiOPMachSalary:       Result:=evtNone;
    epiReturn:             Result:=evtNone;
    epiVAT:                Result:=evtNone;
    epiWinter:             Result:=evtNone;
    epiLaborWorker:        Result:=evtWorkerLabor;
    epiLaborMachinist:     Result:=evtMachinistLabor;
    epiUndefine:           Result:=evtNone;
    else                   Result:=evtNone;
  end;
end;

function EstResTypeFromStr(const S: string; out ResType: TEstimateResourceType): Boolean;
var i: TEstimateResourceType;
begin
  if Length(EstResourceTypeNames)=0 then Result := False
  else
    for i := Low(EstResourceTypeNames) to High(EstResourceTypeNames) do begin
      Result := EstResourceTypeNames[i]=S;
      if Result then begin ResType := i; Break; end;
    end;
end;

function DocTypeToText(const edt: TEstDocType): RawUtf8;
var s: string;
begin
  case edt of
    edtLEC:   s:='ЛСР';
    edtOEC:   s:='ОСР';
    edtSEC:   s:='ССРСС';
    edtMA:    s:='КАЦ';
    edtMAD:   s:='КАД';
    edtCS:    s:='СЗ';
    edtLOV:   s:='ВОР';
    edtCSWV:  s:='СВОР';
    edtCSCEC: s:='СВИС';
    edtCalc:  s:='СР';
    edtCalc1: s:='СР1';
    edtCalc2: s:='СР2';
    edtCalc3: s:='СР3';
    edtCalc4: s:='СР4';
    edtTrans: s:='ТС';
    edtOther: s:='ДР';
    edtExpl:  s:='ПЗ';
    edtNone:  S:='';
  end;
  Result:=StringToUtf8(s);
end;

function DocTypeFromText(const edt: RawUtf8): TEstDocType;
var s: string;
begin
  s:=Utf8ToString(edt);
  if      s=''      then Result:=edtNone
  else if s='ЛСР'   then Result:=edtLEC
  else if s='ОСР'   then Result:=edtOEC
  else if s='ССРСС' then Result:=edtSEC
  else if s='КАЦ'   then Result:=edtMA
  else if s='КАД'   then Result:=edtMAD
  else if s='СЗ'    then Result:=edtCS
  else if s='ВОР'   then Result:=edtLOV
  else if s='СВОР'  then Result:=edtCSWV
  else if s='СВИС'  then Result:=edtCSCEC
  else if s='СР'    then Result:=edtCALC
  else if s='СР1'   then Result:=edtCALC1
  else if s='СР2'   then Result:=edtCALC2
  else if s='СР3'   then Result:=edtCALC3
  else if s='СР4'   then Result:=edtCALC4
  else if s='ТС'    then Result:=edtTrans
  else if s='ДР'    then Result:=edtOther
  else if s='ПЗ'    then Result:=edtNone
  else                     Result:=edtNone
  ;
end;

{ TEstimateCoefValue }

constructor TEstimateCoefValue.Create(const aValue: Double; const aTarget: TEstimateValueTarget; const aOperation: TEstimateOperationType);
begin
  Value:=aValue; Target:=aTarget; Operation:=aOperation;
end;

function TEstimateCoefValue.IsOne: Boolean;
begin
  Result := EstValueIsOne(Value)
end;

function TEstimateCoefValue.IsZero: Boolean;
begin
  Result := EstValueIsZero(Value)
end;

class function TEstimateCoefValue.StringAsTarget(const Str: string): TEstimateValueTarget;
begin
  if      Str='ОТ'  then Result:=evtWorkerSalary
  else if Str='ЭМ'  then Result:=evtMachines
  else if Str='ОТМ' then Result:=evtMachinistSalary
  else if Str='МАТ' then Result:=evtMaterial
  else if Str='ЗТ'  then Result:=evtWorkerLabor
  else if Str='ЗТМ' then Result:=evtMachinistLabor
  else if Str='ПЗ'  then Result:=evtDirect
  else                   Result:=evtNone;

end;

class function TEstimateCoefValue.TargetAsRawUTF8(const ValueTarget: TEstimateValueTarget): RawUtf8;
begin
  Result:=StringToUtf8(TargetAsString(ValueTarget));
end;

class function TEstimateCoefValue.TargetAsString(const ValueTarget: TEstimateValueTarget): string;
begin
  case ValueTarget of
    evtDirect:          Result:=rusPZ;
    evtWorkerSalary:    Result:='ОТ';
    evtWorkerFund:      Result:='ОТ';
    evtMachines:        Result:='ЭМ';
    evtMachinistSalary: Result:='ОТМ';
    evtMachinistFund:   Result:='ОТМ';
    evtMaterial:        Result:='МАТ';
    evtEquipment:       Result:='ОБ';
    evtWorkerLabor:     Result:='ЗТ';
    evtMachinistLabor:  Result:='ЗТМ';
    evtPrice:           Result:='Стоимость';
    evtVolume:          Result:='Объем';
    evtConsumption:     Result:='Расход';
    evtPortage:         Result:=rusMat;
    evtWageFund:        Result:='';
    evtCIW:             Result:='';
    evtOverheadBC:      Result:='';
    evtProfitBC:        Result:='';
    evtOverheadB:       Result:='';
    evtProfitB:         Result:='';
    evtOverheadC:       Result:='';
    evtProfitC:         Result:='';
    evtNone:            Result:='';
  end;
end;

{ TEstimateDate }

constructor TEstimateDate.Create(const aDate: TDateTime);
begin
  SetDate(aDate); FNote:='';
end;

constructor TEstimateDate.Create(const aYear, aMonth, aDay: Word);
begin
  FYear := aYear; FMonth := aMonth; FDay := aDay; FNote:='';
end;

function TEstimateDate.GetDate: TDateTime;
var dt: TDateTime;
begin
  if FYear<=0 then Result:=0
  else if FMonth<=0 then Result:=EncodeDate(FYear,1,1)
  else if FDay<=0 then Result:=EncodeDate(FYear,FMonth,1)
  else begin
    if not TryEncodeDate(FYear,FMonth,FDay, dt) then dt := EncodeDate(FYear,FMonth,1);
    Result:=dt;
  end;
end;

function TEstimateDate.isValidDate: Boolean;
var d: TDateTime;
begin
  Result := TryEncodeDate(FYear,FMonth,Fday, d);
end;

function TEstimateDate.Quarter: Word;
begin
  if (Month<>0) and isValidDate then Result:=((Month-1) div 3) + 1
                                else Result:=0;
end;

procedure TEstimateDate.SetDate(const Value: TDateTime);
begin
  DecodeDate(Value, FYear, FMonth, FDay);
end;

procedure TEstimateDate.SetNote(const Value: string);
begin
  FNote:=Value;
end;

{ TEstimateExpense }

constructor TEstimateExpense.Create(const aReason, aName: string; const aValue: Double; const aOpType: TEstimateOperationType);
begin
  SetName(aName); SetReason(aReason); SetValue(aValue); SetOperationType(aOpType);
end;

procedure TEstimateExpense.SetName(const Value: string);
begin
  FName := Value;
end;

procedure TEstimateExpense.SetOperationType(const Value: TEstimateOperationType);
begin
  FOperationType := Value;
end;

procedure TEstimateExpense.SetReason(const Value: string);
begin
  FReason := Value;
end;

procedure TEstimateExpense.SetValue(const Value: Double);
begin
  FValue := Value;
end;

{ TEstimatePrice }

procedure TEstimatePrice.Clear;
var i:TEstimatePriceItemType;
begin
  for i := Low(Items) to High(Items) do Items[i]:=0;
end;

constructor TEstimatePrice.Create(const aPrice: Double);
begin
  Clear;
  SetPrice(aPrice);
end;

function TEstimatePrice.GetConstruction: Double;
begin
  Result:=Items[epiConstruction];
end;

function TEstimatePrice.GetEquipment: Double;
begin
  Result:=Items[epiEquipment];
end;

function TEstimatePrice.GetInstallation: Double;
begin
  Result:=Items[epiInstallation];
end;

function TEstimatePrice.GetItem(Index: TEstimatePriceItemType): Double;
begin
  Result:=Items[Index];
end;

function TEstimatePrice.GetMachines: Double;
begin
  Result:=Items[epiMachines];
end;

function TEstimatePrice.GetMachinistSalary: Double;
begin
  Result:=Items[epiMachinistSalary];
end;

function TEstimatePrice.GetMaterials: Double;
begin
  Result:=Items[epiMaterial];
end;

function TEstimatePrice.GetOther: Double;
begin
  Result:=Items[epiOther];
end;

function TEstimatePrice.GetOverhead: Double;
begin
  Result:=Items[epiOverhead];
end;

function TEstimatePrice.GetPrice: Double;
begin
  Result:=Items[epiPrice];
end;

function TEstimatePrice.GetProfit: Double;
begin
  Result:=Items[epiProfit];
end;

function TEstimatePrice.GetWorkersSalary: Double;
begin
  Result:=Items[epiWorkersSalary];
end;

function TEstimatePrice.isNull: Boolean;
var i: TEstimatePriceItemType;
begin
  Result := False;
  for i := Low(TEstimatePriceItemType) to High(TEstimatePriceItemType) do if not EstValueIsZero(Items[i]) then Exit;
  Result := True;
end;

procedure TEstimatePrice.SetConstruction(const Value: Double);
begin
  Items[epiConstruction]:=Value;
end;

procedure TEstimatePrice.SetEquipment(const Value: Double);
begin
  Items[epiConstruction]:=Value;
end;

procedure TEstimatePrice.SetInstallation(const Value: Double);
begin
  Items[epiConstruction]:=Value;
end;

procedure TEstimatePrice.SetItem(Index: TEstimatePriceItemType; const Value: Double);
begin
  Items[Index]:=Value;
end;

procedure TEstimatePrice.SetMachines(const Value: Double);
begin
  Items[epiMachines]:=Value;
end;

procedure TEstimatePrice.SetMachinistSalary(const Value: Double);
begin
  Items[epiMachinistSalary]:=Value;
end;

procedure TEstimatePrice.SetMaterials(const Value: Double);
begin
  Items[epiMaterial]:=Value;
end;

procedure TEstimatePrice.SetOther(const Value: Double);
begin
  Items[epiOther]:=Value;
end;

procedure TEstimatePrice.SetOverhead(const Value: Double);
begin
  Items[epiOverhead]:=Value;
end;

procedure TEstimatePrice.SetPrice(const Value: Double);
begin
  Items[epiPrice]:=Value;
end;

procedure TEstimatePrice.SetProfit(const Value: Double);
begin
  Items[epiProfit]:=Value;
end;

procedure TEstimatePrice.SetWorkersSalary(const Value: Double);
begin
  Items[epiWorkersSalary]:=Value;
end;

{ TEstPriceLevel }

constructor TEstimatePriceLevel.Create(const aYear, aMonth, aDay: Word; const aNote: string='');
var s,mm: string;
begin
  s := DBDTrim(aNote);
  if Length(s)>5 then begin
    mm:=copy(s,1,2);
    FYear := StrToIntDef(copy(s,4,2),0);
    if FYear>0 then FYear:= FYear+2000;
    FMonth := StrToIntDef(copy(s,1,2),0);
  end;
  if      aYear<30  then FYear := aYear + 2000
  else if aYear<100 then FYear := aYear + 1900
  else FYear:=aYear;
  if (aMonth>0) and (aMonth<13) then FMonth := aMonth
  else if aMonth>12             then FMonth := 12
  else                               FMonth := 1;
  if (aDay>0) and (aDay<31) then FDay:=aDay else FDay:=0;
  SetNote(aNote);
end;

constructor TEstimatePriceLevel.Create(const aDate: TDateTime; const aNote: string='');
begin
  SetDate(aDate); SetNote(aNote);
end;

constructor TEstimatePriceLevel.Create(const aStr: string);
var i: Integer; dt: TDateTime;
begin
  FNote:=aStr; i:=1; FYear:=2000; FMonth:=1; FDay:=0;
  if aStr='' then Exit;
  if DBDReadDate(aStr,i,dt, dbdDOFirstDay, 0) then begin
    SetDate(dt);
//    FNote := Copy(aStr, i, Length(aStr)-i+1);
    FNote:=DBDTrim(FNote);
  end;
end;

function TEstimatePriceLevel.DateFromStr(const aStr: string): Boolean;
var i: Integer; dt: TDateTime;
begin
  i:=1; Result:=(aStr<>'') and DBDReadDate(aStr,i,dt, dbdDOFirstDay, 0);
  if Result then SetDate(dt)
end;

function TEstimatePriceLevel.GetDate: TDateTime;
var dt: TDateTime;
begin
  if FYear<=0 then Result:=0
  else if FMonth<=0 then Result:=EncodeDate(FYear,1,1)
  else if FDay<=0 then Result:=EncodeDate(FYear,FMonth,1)
  else begin
    if not TryEncodeDate(FYear,FMonth,FDay, dt) then dt := EncodeDate(FYear,FMonth,1);
    Result:=dt;
  end;
end;

function TEstimatePriceLevel.IdxAuthorTS(const aStr: string): string;
var i: Integer; s: string;
begin
  s:=DBDTrim(aStr);
  i:=Pos(' ', s);
  if i>1 then Result:=Copy(s,i+1)
         else Result:=s;
  Result:=DBDTrim(Result)
end;

function TEstimatePriceLevel.IdxAuthorTSUtf8(const aTxt: RawUtf8): RawUtf8;
var s: string;
begin
  s:=Utf8ToString(aTxt);
  s:=IdxAuthorTS(s);
  Result:=StringToUtf8(s);
end;

function TEstimatePriceLevel.PLText(const Sep: Boolean=True): string;
begin
  if Sep then Result:=Format('%2.2d',[FMonth]) + '/' + Copy(Format('%4.4d',[FYear]),3,2)
  else Result:=Format('%2.2d',[FMonth]) + Copy(Format('%4.4d',[FYear]),3,2);
end;

function TEstimatePriceLevel.Quarter: Integer;
begin
  Result:=((FMonth-1) div 3)+1;
end;

procedure TEstimatePriceLevel.SetDate(const Value: TDateTime);
begin
  DecodeDate(Value, FYear, FMonth, FDay);
end;

procedure TEstimatePriceLevel.SetDescription(const Value: string);
begin
  FDescription:=Value;
end;

procedure TEstimatePriceLevel.SetNormOverdraft(const Value: Double);
begin
  FNormOverdraft:=Value;
end;

procedure TEstimatePriceLevel.SetNormProfit(const Value: Double);
begin
  FNormProfit:=Value;
end;

procedure TEstimatePriceLevel.SetNote(const Value: string);
begin
  FNote := Value;
end;

function TEstimatePriceLevel.ToDateStr(const Sep: AnsiChar): string;
begin
  Result:=Format('%2.2d',[FDay]) +'.' + Format('%2.2d',[Month]) + '.' +IntToStr(FYear);
end;

function TEstimatePriceLevel.ToDoc: Variant;
begin
  Result:=_Obj(['Year',FYear,'Month',FMonth, 'Day', FDay, 'Note', StringToUtf8(FNote)]);
  if FDescription<>'' then TDocVariantData(Result).AddValue('Desc', FDescription);
  if FNormOverdraft>0.0 then TDocVariantData(Result).AddValue('novr', FNormOverdraft);
  if FNormProfit>0.0 then TDocVariantData(Result).AddValue('nprf', FNormProfit);
end;

function TEstimatePriceLevel.ToText(const Quarter: Boolean): string;
begin
  if Quarter then begin
    if      FMonth<4  then Result:= '1'
    else if FMonth<7  then Result:= '2'
    else if FMonth<10 then Result:= '3'
    else                   Result:= '4';
    Result:=Result+' кв ';
  end else begin
    Result:= IntToStr(FMonth) + '/';
  end;
  Result:=Result + IntToStr(FYear);
end;

function TEstimatePriceLevel.FromDoc(pDoc: PDocVariantData): Boolean;
var i,y,m: Integer; var r: RawUtf8; d: Double;
begin
  Result := pDoc^.getAsInteger('Year',y) and (y>=0)
        and pDoc^.getAsInteger('Month',m) and (m>=0) and (m<13);
  if Result then begin
    FYear:=y; FMonth:=m;
    if pDoc^.getAsInteger('Day',i) then FDay:=i else FDay:=0;
    if pDoc^.GetAsRawUtf8('Note', r) then FNote:=Utf8ToString(r) else FNote:='';
  end;
  if pDoc^.GetAsRawUtf8('Desc', r) then FDescription:=Utf8ToString(r) else FDescription:='';
  if not pDoc^.GetAsDouble('novr', FNormOverdraft) then FNormOverdraft:=0.0;
  if not pDoc^.GetAsDouble('nprf', FNormProfit) then FNormProfit:=0.0;
end;


{ TEstPositionLaborCost }

procedure TEstPositionLaborCost.Clear;
var i: TEstPositionLaborItemType;
begin
  for i := Low(Items) to High(Items) do Items[i]:=0;
end;

constructor TEstPositionLaborCost.Create(const aWorker, aMachinist: Double);
begin
  Items[epliWorker]:=aWorker;
  Items[epliMachinist]:=aMachinist;
end;

function TEstPositionLaborCost.GetItem(Index: TEstPositionLaborItemType): Double;
begin
  Result := Items[Index];
end;

function TEstPositionLaborCost.isNull: Boolean;
var i: TEstPositionLaborItemType;
begin
  Result := False;
  for i := Low(TEstPositionLaborItemType) to High(TEstPositionLaborItemType) do if Items[i]<>0 then Exit;
  Result := True;
end;

procedure TEstPositionLaborCost.SetItem(Index: TEstPositionLaborItemType; const Value: Double);
begin
  Items[Index]:=Value;
end;

{ TEstPositionPrice }

procedure TEstPositionPrice.Clear;
var i: TEstPositionPriceItemType;
begin
  for i := Low(Items) to High(Items) do Items[i]:=0;
end;

constructor TEstPositionPrice.Create(const aPrice: Double);
begin
  Clear;
  Items[eppiDirect]:=aPrice;
end;

constructor TEstPositionPrice.Create(const aWorker, aMachines, aMachinist, aMaterials: Double);
begin
  Create(0);
  Items[eppiWorker]:=aWorker;
  Items[eppiMachines]:=aMachines;
  Items[eppiMachinist]:=aMachinist;
  Items[eppiMaterial]:=aMaterials;
end;

function TEstPositionPrice.GetItem(Index: TEstPositionPriceItemType): Double;
begin
  Result:=Items[Index];
end;

function TEstPositionPrice.GetPrice: Double;        //???????????????????????????????????????????????????????????
var i: TEstPositionPriceItemType;
begin
  if Items[eppiDirect] <> 0 then Result := Items[eppiDirect]
  else
    for i := Low(TEstPositionPriceItemType) to High(TEstPositionPriceItemType) do
      if Items[i]<>0 then begin
        Result := Items[i]; Break;
      end;
end;

function TEstPositionPrice.isDirectOnly: Boolean;
var i: TEstPositionPriceItemType;
begin
  Result := not EstValueIsZero(Items[eppiDirect]);
  if Result then
    for i := Low(TEstPositionPriceItemType) to High(TEstPositionPriceItemType) do begin
      if (i<>eppiDirect) and (not EstValueIsZero(Items[i])) then begin
        Result := False; Break;
      end;
    end;
end;

function TEstPositionPrice.isNull: Boolean;
var i: TEstPositionPriceItemType;
begin
  Result := False;
  for i := Low(TEstPositionPriceItemType) to High(TEstPositionPriceItemType) do if Items[i]<>0 then Exit;
  Result := True;
end;

procedure TEstPositionPrice.SetItem(Index: TEstPositionPriceItemType; const Value: Double);
begin
  Items[Index]:=Value;
end;

{ TEstimateCoefficient }

constructor TEstimateCoefficient.Create(const aName: string; const aValue: Double; const aOp: TEstimateOperationType; const aToNum: Byte);
begin
  SetName(aName); SetValue(aValue); SetOperaion(aOp);
  SetNum(0); SetToNum(aToNum);
end;

function TEstimateCoefficient.isNull: Boolean;
begin
  Result := false
end;

procedure TEstimateCoefficient.SetName(const NewValue: string);
begin
  FName := NewValue;
end;

procedure TEstimateCoefficient.SetNum(const NewValue: Byte);
begin
  FNum := NewValue;
end;

procedure TEstimateCoefficient.SetOperaion(const NewValue: TEstimateOperationType);
begin
  FOperaion := NewValue;
end;

procedure TEstimateCoefficient.SetReason(const NewValue: string);
begin
  FReason := NewValue;
end;

procedure TEstimateCoefficient.SetToNum(const NewValue: Byte);
begin
  FToNum := NewValue;
end;

procedure TEstimateCoefficient.SetValue(const NewValue: Double);
begin
  FValue := NewValue;
end;

{ TEstSignature }

procedure TEstSignature.Clear;
begin
  FFIO:=''; FCode:=ejcUndefine; FJob:='';
end;

constructor TEstSignature.Create(const aCode: TEstJobCode; const aFIO: string; const aPost: string);
begin
  SetCode(aCode); SetFIO(aFIO); SetJob(aPost);
end;

procedure TEstSignature.CopyFrom(Src: TEstSignature);
begin
  SetCode(Src.Code); SetFIO(Src.FIO); SetJob(Src.Job);
end;

constructor TEstSignature.Create(const PDoc: PDocVariantData);
begin
  if (PDoc=nil) or (not FromDoc(PDoc)) then Clear;
end;

function TEstSignature.FromDoc(const Json: RawUtf8): Boolean;
var v: Variant; p: PDocVariantData;
begin
  if Json='' then Result:=False
  else begin
    TDocVariant.New(v); p:=_Safe(v);
    Result:=FromDoc(p);
  end;
end;

function TEstSignature.FromDoc(const PDoc: PDocVariantData): Boolean;
var r: RawUtf8; i: Integer;
begin
  Clear;
  if PDoc=nil then Result:=False
  else begin
    Result:=PDoc^.GetAsInteger('cod', i); if not Result then Exit;
    FCode:= TEstJobCode(i);
    Result:=PDoc^.GetAsRawUtf8('fio', r); if not Result then Exit;
    FFIO:=Utf8ToString(r);
    if PDoc^.GetAsRawUtf8('job', r) then FJob:=Utf8ToString(r);
  end;
end;

function TEstSignature.GetEmpty: Boolean;
begin
  Result:=(FFIO='');
end;

procedure TEstSignature.SetCode(const Value: TEstJobCode);
begin
  FCode := Value;
end;

procedure TEstSignature.SetEmpty(const Value: Boolean);
begin
  if Value then Clear;
end;

procedure TEstSignature.SetFIO(const Value: string);
begin
  FFIO := Value;
end;


procedure TEstSignature.SetJob(const Value: string);
begin
  FJob:=Value;
end;

function TEstSignature.ToDoc: Variant;
begin
  Result:=_Obj(['cod', Ord(FCode), 'fio',StringToUtf8(FFIO)]);
  if FJob<>'' then TDocVariantData(Result).AddValue('job', StringToUtf8(FJob));
end;

procedure InitModule;
begin

  BooksJName                  := StringToUtf8('Books');
  DocTypeJName                := StringToUtf8('DocType');
  FlagEdjJName                := StringToUtf8('printEdj');
  FlagFolderJName             := StringToUtf8('CreateFldr');
  FlagSaveSrcExtJName         := StringToUtf8('SaveExtension');
  FlagEmbededJName            := StringToUtf8('SaveEmbeded');
  FlagCheckResultJName        := StringToUtf8('DoCheck');
  FlagShowResultJName         := StringToUtf8('ShowHtml');
  FlagExtentionIsXMLJName     := StringToUtf8('ExtentionIsXML');
  FlagIgnoreZerosfXMLJName    := StringToUtf8('IgnoreZeros');
  FlagIgnoreSubZerosfXMLJName := StringToUtf8('IgnoreSubZeros');
  FlagSkipEmptySectionJName   := StringToUtf8('SkipEmptySection');
  FlagZeroPriceWriteJName     := StringToUtf8('ZeroPriceWrite');
  FlagPriceLevelBaseXMLJName  := StringToUtf8('BasePrices');
  FlagTotalsOnlyXMLJName      := StringToUtf8('TotalsOnly');
  FlagCalcFromCurrXMLJName    := StringToUtf8('FlagCalcFromCurr');
  FlagResFromCurrXMLJName     := StringToUtf8('FlagResFromCurr');
//  FlagEmptySectionIgnoreJName := StringToUtf8('FlagEmptySectionIgnore');
  FlagEmptyLinksIgnoreJName   := StringToUtf8('FlagEmptyLinksIgnore');
  FlagQtyFormulaXMLJName      := StringToUtf8('FlagQtyFormulaIgnore');
  FlagEmptyFormulasJName      := StringToUtf8('FlagEmptyFormulas');
  LocEstSchemaJName           := StringToUtf8('SchemaLEC');
  MethodJName                 := StringToUtf8('EstMethod');
  NoTotalsJName               := StringToUtf8('NoTotals');;
  ObjEstSchemaJName           := StringToUtf8('SchemaOEC');
  OrderIdJName                := StringToUtf8('OrderID');
  OverdraftJName              := StringToUtf8('Overdraft');
  ProfitJName                 := StringToUtf8('Profit');
  PriceLevelIdJName           := StringToUtf8('PriceLevel');
  SumConsistJName             := StringToUtf8('SumConsist');
  SchemaJName                 := StringToUtf8('Schema');
  SumEstSchemaJName           := StringToUtf8('SchemaSEC');
  TmpltJName                  := StringToUtf8('Tmplt');
  UseSubNumJName              := StringToUtf8('UseSubNum');
  UsePosNumJName              := StringToUtf8('UsePosNum');
  UsePortageNumJName          := StringToUtf8('UsePortageNum');
  CalcTotalsJName             := StringToUtf8('CalcTotals');
  CostsSummaryJName           := StringToUtf8('CostsSummary');
  CSOutputSwitchJName         := StringToUtf8('CSOutput');
  RIMEstSchemaVerJName        := StringToUtf8('RIMVer');
  LECVersionJName          := StringToUtf8('LECVer');
  BIMVersionJName          := StringToUtf8('BIMVer');
  RIMVersionJName          := StringToUtf8('RIMVer');
  OECVersionJName          := StringToUtf8('OECVer');
//  OECBasePricesJName       := StringToUtf8('OECBasePrice');
  SECVersionJName          := StringToUtf8('SECVer');
  MANVersionJName          := StringToUtf8('MANVer');
  MANFlagFormulaInNameJName:= StringToUtf8('FlagFormulaInName');
  LOVVersionJName          := StringToUtf8('LOVVer');
  CSBasePricesEnabledJName := StringToUtf8('SCBasePriceEnabled');
  CSVATIntoTableJName      := StringToUtf8('SCVATIntTable');
  CSDummyRoundJName        := StringToUtf8('CSDummyRound');
  CSEstimatesOnlyJName     := StringToUtf8('EstimatesOnly');
  DestFileJName            := StringToUtf8('DestFile');
  DestinationSchemaJName   := StringToUtf8('DestinationSchema');
  MGEDestFlagJName         := StringToUtf8('mge');
  DestFolderJName          := StringToUtf8('DestFldr');
  FlagNoEstExportJName     := StringToUtf8('NoExportEst');
  PrcFormulaJName          := StringToUtf8('PrcFormula');
  QtyFormulaJName          := StringToUtf8('QtyFormula');
  FlagFormulaInNameJName   := StringToUtf8('FormulaInName');
{$IFDEF ISDELPHIXE2}
  EstimateFormatSettings:=TFormatSettings.Create;
{$ELSE}
  GetLocaleFormatSettings(0,EstimateFormatSettings);
{$ENDIF}
  EstCoefficientNull := TEstimateCoefficient.Create('Null',0);
  EstCoefValueNull := TEstimateCoefValue.Create(0,evtDirect);
  DefaultMeta.Default;

  EstimatePriceDeltaZero:=0.0001;
  EstimateValueDeltaZero:=0.000001;
  EstimatePricePrecision:=4;
  EstimateQuantityPrecision:=8;
  EstimateValuePrecision:=6;

  EstPositionTypeNames[eptFER]      := rusFER;
  EstPositionTypeNames[eptFERm]     := rusFERm;
  EstPositionTypeNames[eptFERmr]    := rusFERmr;
  EstPositionTypeNames[eptFERr]     := rusFERr;
  EstPositionTypeNames[eptFERp]     := rusFERp;
  EstPositionTypeNames[eptTER]      := rusTER;
  EstPositionTypeNames[eptTERm]     := rusTERm;
  EstPositionTypeNames[eptTERmr]    := rusTERmr;
  EstPositionTypeNames[eptTERr]     := rusTERr;
  EstPositionTypeNames[eptTERp]     := rusTERp;
  EstPositionTypeNames[eptGESN]     := rusGESN;
  EstPositionTypeNames[eptGESNm]    := rusGESNm;
  EstPositionTypeNames[eptGESNmr]   := rusGESNmr;
  EstPositionTypeNames[eptGESNr]    := rusGESNr;
  EstPositionTypeNames[eptGESNp]    := rusGESNp;
  EstPositionTypeNames[eptKSR]      := rusKSR;
  EstPositionTypeNames[eptFSSC]     := rusFSSC;
  EstPositionTypeNames[eptFSSCpg]   := rusFSSCpg;
  EstPositionTypeNames[eptFSBC]     := rusFSBC;
  EstPositionTypeNames[eptFSBCm]    := rusFSBCm;
  EstPositionTypeNames[eptFSBCpg]   := rusFSBCpg;
  EstPositionTypeNames[eptTSSC]     := rusTSSC;
  EstPositionTypeNames[eptTSSCpg]   := rusTSSCpg;
  EstPositionTypeNames[eptFSEM]     := rusFSEM;
  EstPositionTypeNames[eptTSEM]     := rusTSEM;
  EstPositionTypeNames[eptTSN]      := rusTSN;
  EstPositionTypeNames[eptOSSCG]    := rusOSSCG;
  EstPositionTypeNames[eptOSSPG]    := rusOSSPG;
  EstPositionTypeNames[eptOSEMG]    := rusOSEMG;
  EstPositionTypeNames[eptOERG]     := rusOERG;
  EstPositionTypeNames[eptOERGm]    := rusOERGm;
  EstPositionTypeNames[eptOERGr]    := rusOERGr;
  EstPositionTypeNames[eptOERGp]    := rusOERGp;
  EstPositionTypeNames[eptOERGmr]   := rusOERGmr;
  EstPositionTypeNames[eptOERGkr]   := rusOERGkr;
  EstPositionTypeNames[eptOSCGo]    := rusOSCGo;
  EstPositionTypeNames[eptPriceMat] := rusPriceMat;
  EstPositionTypeNames[eptPriceEqu] := rusPriceEqu;
  EstPositionTypeNames[eptPIR]      := '';
  EstPositionTypeNames[eptComment]  := '';
  EstPositionTypeNames[eptUnknown]  := '';
  EstPositionTypeNamesUTF8[eptFER]      := StringToUTF8(rusFER);
  EstPositionTypeNamesUTF8[eptFERm]     := StringToUTF8(rusFERm);
  EstPositionTypeNamesUTF8[eptFERmr]    := StringToUTF8(rusFERmr);
  EstPositionTypeNamesUTF8[eptFERr]     := StringToUTF8(rusFERr);
  EstPositionTypeNamesUTF8[eptFERp]     := StringToUTF8(rusFERp);
  EstPositionTypeNamesUTF8[eptTER]      := StringToUTF8(rusTER);
  EstPositionTypeNamesUTF8[eptTERm]     := StringToUTF8(rusTERm);
  EstPositionTypeNamesUTF8[eptTERmr]    := StringToUTF8(rusTERmr);
  EstPositionTypeNamesUTF8[eptTERr]     := StringToUTF8(rusTERr);
  EstPositionTypeNamesUTF8[eptTERp]     := StringToUTF8(rusTERp);
  EstPositionTypeNamesUTF8[eptGESN]     := StringToUTF8(rusGESN);
  EstPositionTypeNamesUTF8[eptGESNm]    := StringToUTF8(rusGESNm);
  EstPositionTypeNamesUTF8[eptGESNmr]   := StringToUTF8(rusGESNmr);
  EstPositionTypeNamesUTF8[eptGESNr]    := StringToUTF8(rusGESNr);
  EstPositionTypeNamesUTF8[eptGESNp]    := StringToUTF8(rusGESNp);
  EstPositionTypeNamesUTF8[eptKSR]      := StringToUTF8(rusKSR);
  EstPositionTypeNamesUTF8[eptFSSC]     := StringToUTF8(rusFSSC);
  EstPositionTypeNamesUTF8[eptFSSCpg]   := StringToUTF8(rusFSSCpg);
  EstPositionTypeNamesUTF8[eptTSSC]     := StringToUTF8(rusTSSC);
  EstPositionTypeNamesUTF8[eptTSSCpg]   := StringToUTF8(rusTSSCpg);
  EstPositionTypeNamesUTF8[eptFSEM]     := StringToUTF8(rusFSEM);
  EstPositionTypeNamesUTF8[eptTSEM]     := StringToUTF8(rusTSEM);
  EstPositionTypeNamesUTF8[eptTSN]      := StringToUTF8(rusTSN);
  EstPositionTypeNamesUTF8[eptOSSCG]    := StringToUTF8(rusOSSCG);
  EstPositionTypeNamesUTF8[eptOSSPG]    := StringToUTF8(rusOSSPG);
  EstPositionTypeNamesUTF8[eptOSEMG]    := StringToUTF8(rusOSEMG);
  EstPositionTypeNamesUTF8[eptOERG]     := StringToUTF8(rusOERG);
  EstPositionTypeNamesUTF8[eptOERGm]    := StringToUTF8(rusOERGm);
  EstPositionTypeNamesUTF8[eptOERGr]    := StringToUTF8(rusOERGr);
  EstPositionTypeNamesUTF8[eptOERGp]    := StringToUTF8(rusOERGp);
  EstPositionTypeNamesUTF8[eptOERGmr]   := StringToUTF8(rusOERGmr);
  EstPositionTypeNamesUTF8[eptOERGkr]   := StringToUTF8(rusOERGkr);
  EstPositionTypeNamesUTF8[eptOSCGo]    := StringToUTF8(rusOSCGo);
// пока так
//  EstPositionTypeNamesUTF8[eptOERG]     := StringToUTF8(rusTER);
//  EstPositionTypeNamesUTF8[eptOERGm]    := StringToUTF8(rusTERm);
//  EstPositionTypeNamesUTF8[eptOERGr]    := StringToUTF8(rusTERr);
//  EstPositionTypeNamesUTF8[eptOERGp]    := StringToUTF8(rusTERp);
//  EstPositionTypeNamesUTF8[eptOERGmr]   := StringToUTF8(rusTERmr);
//  EstPositionTypeNamesUTF8[eptOERGkr]   := StringToUTF8(rusTERkr);
  EstPositionTypeNamesUTF8[eptOSCGo]    := StringToUTF8(rusOSCGo);
  EstPositionTypeNamesUTF8[eptPriceMat] := StringToUTF8(rusPriceMat);
  EstPositionTypeNamesUTF8[eptPriceEqu] := StringToUTF8(rusPriceEqu);
  EstPositionTypeNamesUTF8[eptPIR]      := '';
  EstPositionTypeNamesUTF8[eptComment]  := '';
  EstPositionTypeNamesUTF8[eptUnknown]  := '';


  EstResourceTypeNames[ertWorker]    := rusZTR;
  EstResourceTypeNames[ertMachinist] := rusZTM;
  EstResourceTypeNames[ertMachines]  := rusEMM;
  EstResourceTypeNames[ertMaterial]  := rusMAT;
  EstResourceTypeNames[ertEquipment] := rusOB;
  EstResourceTypeNamesUTF8[ertWorker]    := StringToUTF8(EstResourceTypeNames[ertWorker]);
  EstResourceTypeNamesUTF8[ertMachinist] := StringToUTF8(EstResourceTypeNames[ertMachinist]);
  EstResourceTypeNamesUTF8[ertMachines]  := StringToUTF8(EstResourceTypeNames[ertMachines]);
  EstResourceTypeNamesUTF8[ertMaterial]  := StringToUTF8(EstResourceTypeNames[ertMaterial]);
  EstResourceTypeNamesUTF8[ertEquipment] := StringToUTF8(EstResourceTypeNames[ertEquipment]);

  EstValueTargetNames[evtDirect]          := rusPZ;
  EstValueTargetNames[evtWorkerSalary]    := rusOZP;
  EstValueTargetNames[evtMachines]        := rusEM;
  EstValueTargetNames[evtMachinistSalary] := rusZPM;
  EstValueTargetNames[evtMaterial]        := rusMAT;
  EstValueTargetNames[evtEquipment]       := rusOB;
  EstValueTargetNames[evtWorkerLabor]     := rusTZ;
  EstValueTargetNames[evtMachinistLabor]  := rusTZM;
  EstValueTargetNames[evtVolume]          := rusVolume;
  EstValueTargetNames[evtConsumption]     := rusConsumption;
  EstValueTargetNames[evtWageFund]        := rusFOT;
  EstValueTargetNames[evtCIW]             := rusSMR;
  EstValueTargetNames[evtPrice]           := rusPrice;

  EstValueTargetNames[evtNone]            := '';
  EstValueTargetNamesUTF8[evtDirect]          := StringToUTF8(EstValueTargetNames[evtDirect]);
  EstValueTargetNamesUTF8[evtWorkerSalary]    := StringToUTF8(EstValueTargetNames[evtWorkerSalary]);
  EstValueTargetNamesUTF8[evtMachines]        := StringToUTF8(EstValueTargetNames[evtMachines]);
  EstValueTargetNamesUTF8[evtMachinistSalary] := StringToUTF8(EstValueTargetNames[evtMachinistSalary]);
  EstValueTargetNamesUTF8[evtMaterial]        := StringToUTF8(EstValueTargetNames[evtMaterial]);
  EstValueTargetNamesUTF8[evtEquipment]       := StringToUTF8(EstValueTargetNames[evtEquipment]);
  EstValueTargetNamesUTF8[evtWorkerLabor]     := StringToUTF8(EstValueTargetNames[evtWorkerLabor]);
  EstValueTargetNamesUTF8[evtMachinistLabor]  := StringToUTF8(EstValueTargetNames[evtMachinistLabor]);
  EstValueTargetNamesUTF8[evtConsumption]     := StringToUTF8(EstValueTargetNames[evtConsumption]);
  EstValueTargetNamesUTF8[evtWageFund]        := StringToUTF8(EstValueTargetNames[evtWageFund]);
  EstValueTargetNamesUTF8[evtCIW]             := StringToUTF8(EstValueTargetNames[evtCIW]);
  EstValueTargetNamesUTF8[evtPrice]           := StringToUTF8(EstValueTargetNames[evtPrice]);
  EstValueTargetNamesUTF8[evtNone] := '';

  SetLength(TotalPriceItemNames,0);

  PriceLevel2001:=TEstimatePriceLevel.Create(2001,1,0);
  PriceLevel2000:=TEstimatePriceLevel.Create(2000,1,0);
  PriceLevel2000MNB:=TEstimatePriceLevel.Create(2000,1,0,'Составлен в базисном уровне цен 1 января 2000');
  PriceLevel2022:=TEstimatePriceLevel.Create(2022,1,0);
  PriceLevelZero:=TEstimatePriceLevel.Create(1960,2,7);
end;

{ TEstMetaInfo }

procedure TEstMetaInfo.Clear;
begin
  FVersion := ''; FSoft_Name := ''; FSoft_Version:='';
end;

procedure TEstMetaInfo.Default;
var fv: TFileVersion; fn: TFileName;
begin
 FVersion := META_DATA_VERSION;
 fn:=IncludeTrailingPathDelimiter(Executable.ProgramFilePath) + 'BExpert.exe';
 if not FileExists(fn) then begin
   fn:='C:\Строительный эксперт\BExpert.exe';
   if not FileExists(fn) then begin
     fn:='G:\Строительный эксперт\BExpert.exe';
   end;
 end;
 FSoft_Name := META_SOFT_NAME;
 if FileExists(fn) then begin
   fv:=TFileVersion.Create(fn);
   try
     if fv.RetrieveInformationFromFileName then begin
       FSoft_Name := FSoft_Name + ' v' + Utf8ToString(fv.FileVersion);
       BExpert_Build:=fv.Build;
     end;
   finally
     FreeAndNil(fv);
   end;
 end;
 FSoft_Version := Executable.InstanceFileName;
 if FileExists(FSoft_Version) then begin
   fv:=TFileVersion.Create(FSoft_Version);
   try
     FSoft_Version := 'Plugin ' + ExtractFileName(FSoft_Version);
     if fv.RetrieveInformationFromFileName then
          FSoft_Version := FSoft_Version + ' v' + Utf8ToString(fv.FileVersion) + ' ' + fv.BuildDateTimeString
     else FSoft_Version := META_SOFT_VERSION + ' ' + fv.BuildDateTimeString;
   finally
     FreeAndNil(fv);
   end;
 end;
end;

procedure TEstMetaInfo.SetSoft_Name(const Value: string);
begin
  FSoft_Name := Value;
end;

procedure TEstMetaInfo.SetSoft_Version(const Value: string);
begin
  FSoft_Version := Value;
end;

procedure TEstMetaInfo.SetVersion(const Value: string);
begin
  FVersion := Value;
end;

{ TEstTotalPriceItem }

constructor TEstTotalPriceItem.Create(const aName: string; aPrice: Double);
begin
  SetPrice(aPrice); SetName(aName);
end;

function TEstTotalPriceItem.GetName: string;
begin
  Result := TotalPriceItemNames[FNameIdx];
end;

function TEstTotalPriceItem.GetNameIdx: Integer;
begin
  Result:=FNameIdx;
end;

procedure TEstTotalPriceItem.SetName(const Value: string);
var i: Integer;
begin
  Assert(Value<>'','Наименование элемента итоговой стоимости не может быть пустым');
  for i := Low(TotalPriceItemNames) to High(TotalPriceItemNames) do
    if TotalPriceItemNames[i]=Value then begin FNameIdx:=i; Exit; end;
  FNameIdx := Length(TotalPriceItemNames);
  SetLength(TotalPriceItemNames,FNameIdx+1);
  TotalPriceItemNames[FNameIdx]:=Value;
end;

procedure TEstTotalPriceItem.SetPrice(const Value: Double);
begin
  FPrice := Value;
end;

{ TEstimateRegion }

procedure TEstimateRegion.Clear;
begin
  FRegionID:=0; FZoneID:=0;
end;

constructor TEstimateRegion.Create(const aID, aZone: Word);
begin
  Clear; SetRegionID(aID); SetZoneID(aZone);
end;

constructor TEstimateRegion.Create(const V: Variant);
begin
  Create(_Safe(V));
end;

constructor TEstimateRegion.Create(const P: PDocVariantData);
var i: Integer;
begin
  Clear; if (P=nil) or (P^.Kind<>dvObject) then Exit;
  if p^.GetAsInteger(RegionIDFieldName,i) then SetRegionID(i);
  if p^.GetAsInteger(ZoneIDFiledName,i) then SetZoneID(i);
end;

function TEstimateRegion.GetState: string;
begin
  Result:=FState;
end;

function TEstimateRegion.GetZoneStr: string;
begin
  if FIndustry='' then Result:=IntToStr(FZoneID)
                  else Result:=FIndustry+'-'+IntToStr(FZoneID);
end;

function TEstimateRegion.IndustryName: string;
begin
  if      FIndustry=rus_RZD then Result:=rusName_RZD
  else if FIndustry=rus_RSS then Result:=rusName_RSS
  else if FIndustry=rus_TRN then Result:=rusName_TRN
  else if FIndustry=rus_RST then Result:=rusName_RST
  else if FIndustry=rus_ALR then Result:=rusName_ALR
  else Result:='';
end;

class function TEstimateRegion.RegionIDByName(const RName: string; const Region: string;
                                              const FromResource: Boolean): Integer;
var r,rn: RawUtf8; i,l: Integer; rr: RawByteString; ls: TStringList; s,sn, sr: string;
begin
  Result:=0;
  if RName='' then Result:=-1
  else if Region='' then Exit
  else if Region=rusRosFed then Exit
  else if FromResource then begin
    ResourceToRawByteString(RName, PChar(10), rr);
    r:=rr;
    if r='' then Result:=-4;
  end else begin
    if FileExists(RName) then r:=StringFromFile(RName)
                         else Result:=-2;
    if r='' then Result:=-3;
  end;
  if Result=0 then begin
    rn:=StringToUtf8(Region);
    i:=PosEx('(', rn);
    if i>1 then  rn:=Copy(rn,1,i-1);
    rn:=UpperCaseUnicode(rn);
    sn:=Utf8ToString(rn);

//    i:=DBDFindChar(sn,'(', 1);
//    if i>1 then begin
//      sn:=Copy(sn,1,i-1); sn:=DBDTrim(sn);
//    end;
    sn:=DBDTrimSubstr(sn,'Г.', dbdSPLeft);
    sn:=DBDReplace(sn,'АО', '');
    sn:=DBDReplace(sn,'АВТОНОМНЫЙ ОКРУГ', '', false, True);
    sn:=DBDReplace(sn,'АВТОНОМНАЯ ОБЛАСТЬ', '', false, True);
    sn:=DBDTrimSpaces(sn);
    sn:=sn+'#';
    l:=Length(sn);
    ls:=TStringList.Create;
    try
      sr:='';
      ls.Text:=Utf8ToString(r);
      for i:=0 to ls.Count-1 do begin
        s:=ls[i];
        if (s='') or (s[1]=';') then Continue;
        s:=AnsiUpperCase(s);
        s:=DBDTrimSubstr(s,'Г.', dbdSPLeft);
        s:=DBDReplace(s,'АО', '');
        s:=DBDReplace(s,'АВТОНОМНЫЙ ОКРУГ', '', false, True);
        s:=DBDReplace(s,'АВТОНОМНАЯ ОБЛАСТЬ', '', false, True);
        s:=DBDReplace(s,' #', '#');
        if Copy(s,1,l)=sn then begin
          sr:=Copy(s, l+1, 2); Break;                  ////////////////////////////////////////////////////////////
        end;
      end;
      if sr<>'' then begin
        Result:=StrToIntDef(sr,0);
      end;
    finally
      ls.Free;
    end;
  end;
end;

class function TEstimateRegion.RegionNameByID(const RName: string; const Region: Word; const FromResource: Boolean): string;
var r: RawUtf8; ra: TRawUtf8List; i: Integer; rr: RawByteString; s: string; sa: TStringDynArray;
begin
  Result:='';
  if Region=0 then Result:=''
  else if FromResource then begin
    ResourceToRawByteString(RName, PChar(10), rr);
    r:=rr;
  end else begin
    if FileExists(RName) then r:=StringFromFile(RName)
                         else Result:='';
  end;
  if r<>'' then begin
    ra:=TRawUtf8List.Create;
    try
      ra.Text:=r;
      for i:=0 to ra.Count-1 do begin
        s:=Utf8ToString(ra[i]);
        DBDStringToArray(s,'#', sa);
        if (Length(sa)>1) and (StrToIntDef(sa[1],0)=Region) then begin
          Result:=sa[0]; Break;
        end;
      end;
    finally
      ra.Free;
    end;
  end;
end;

procedure TEstimateRegion.SetIndustry(const Value: string);
begin
  FIndustry:=Value;
end;

procedure TEstimateRegion.SetRailwayName(const Value: string);
begin
  FRailwayName:=Value;
end;

procedure TEstimateRegion.SetRegionID(const Value: Word);
begin
  FRegionID := Value;
end;

procedure TEstimateRegion.SetRegionName(const Value: string);
begin
  FRegionName := Value;
end;

procedure TEstimateRegion.SetState(const Value: string);
begin
  FState:=Value;
end;

procedure TEstimateRegion.SetZoneID(const Value: Word);
begin
  FZoneID := Value;
end;

procedure TEstimateRegion.SetZoneName(const Value: string);
begin
   FZoneName:=Value;
end;

procedure TEstimateRegion.SetZoneStr(const Value: string);
var i: Integer; s: string;
begin
   if TryStrToInt(Value,i) then begin
     FZoneID:=i; Exit;
   end else begin
     i:=Pos('-',Value);
     if i>0 then begin
       FZoneID:=StrToIntDef(Copy(Value,i+1),0);
       FIndustry:=Copy(Value,1,i-1);
     end else FIndustry:=Value;
   end;
end;

function TEstimateRegion.FromDoc(const PDoc: PDocVariantData): Boolean;
var wR, wZ: Integer; r: RawUtf8;
begin
  Result:=(PDoc<>nil) and (PDoc^.Kind=dvObject) and (PDoc^.Count>1)
       and PDoc^.GetAsInteger(RegionIDFieldName, wR) and (wR>=0)
       and PDoc^.GetAsInteger(ZoneIDFiledName, wZ) and (wZ>=0)
       ;
  if Result then begin
    FRegionID:=wR;
    FZoneID:=wZ;
    if PDoc^.GetAsRawUtf8(RegionNameFieldName, r) then FRegionName:=Utf8ToString(r) else FRegionName:='';
    if PDoc^.GetAsRawUtf8(ZoneNameFiledName, r) then FZoneName:=Utf8ToString(r) else FZoneName:='';
    if PDoc^.GetAsRawUtf8(RailwayNameFiledName, r) then FRailwayName:=Utf8ToString(r) else FRailwayName:='';
    if PDoc^.GetAsRawUtf8(StateFieldName,r) then FState:=Utf8ToString(r) else FState:='';
  end;
end;

function TEstimateRegion.FromStr(const Txt: string): Boolean;
begin

end;

function TEstimateRegion.PatchRailwayZone: Boolean;
var ri, zi: Integer; r,wn, rn, rz: RawUtf8; i,j: Integer; ra: TRawUtf8List; cap,s: string; rr: RawByteString; c: Cardinal;
begin
  ri:=FRegionID; zi:=FZoneID; cap:=FZoneName;
  ResourceToRawByteString(RES_RZD_ZONES, PChar(10), rr);
  Result:=rr<>''; if not Result then Exit;
  r:=rr;
  ra:=TRawUtf8List.Create;
  try
    ra.Text:=r;
    rz:=Format('#%3.3d#%3.3d#',[ri,zi]);
    r:='';
    for i := 0 to ra.Count-1 do begin
      j:=PosEx(rz,ra[i]);
      if (j=7) or (j=8) then begin
        r:=ra[i]; Break;
      end;
    end;
    Result:=r<>''; if not Result then Exit;
    ra.Clear;
    ra.SetText(r, '#');
    r:=ra[ra.Count-1];
    if Split(r,':',wn,rn) then begin
      FRailwayName:=Utf8ToString(TrimU(wn));
      FRegionName:=Utf8ToString(TrimU(rn));
      s:=FRegionName;
      i:=Pos('(',s);
      if i>0 then begin
        inc(i);
        i:=DBDFindStopChar(s,DIGS, i);
        if DBDReadNumber(s,i,c) and (c>0) then FZoneID:=c;
      end else begin
        FZoneID:=zi;
        FZoneName:='';
      end;
      FRegionID:=RegionIDByName(RES_RF_REGIONS, FRegionName, True);
      if FRegionID=0 then begin
        if ri>100 then ri:= ri div 10;
        FRegionID:=ri;
        FRegionName:=RegionNameByID(RES_RF_REGIONS, ri, true);
        Result:=False;
      end;
      if FZoneName='' then FZoneName:= FRailwayName
      else begin
        if FZoneName[1] in ['I','V','X'] then begin
          i:=Pos('. ', FZoneName);
          if i>0 then FZoneName:= Copy(FZoneName,i+2);
        end;
        FZoneName:= FRailwayName + ': ' + FZoneName;
      end;
    end else Result:=False;
  finally
    ra.Free;
  end;
end;

function TEstimateRegion.PatchRailwayZoneFromUtf8(const Txt: RawUtf8): Boolean;
var ri, zi: Integer; r,wn, rn: RawUtf8; i: Integer; ra: TRawUtf8List;
begin
  ra:=TRawUtf8List.Create;
  try
    ra.SetText(Txt,'#');
    r:=ra[ra.Count-1];    //XXX. Railway: Region
    if Split(r,':',wn,rn) then begin
      FRegionName:=Utf8ToString(rn);
      ri:=FRegionID;
      FRegionID:=RegionIDByName(RES_RF_REGIONS, FRegionName, True);
      if FRegionID=0 then FRegionID:=ri;
      FRailwayName:=Utf8ToString(wn);
    end;
  finally
    ra.Free;
  end;
end;

function TEstimateRegion.PatchRailwayZoneID: Boolean;
var rr: RawByteString; r ,wn, rn, rz: RawUtf8; ra: TRawUtf8List; i,k: Integer; s: string; flds: TRawUtf8DynArray;
begin
  Result:=(FRegionID<>0) and (FRegionName<>'') and (FZoneName<>''); if not Result then Exit;
  Result := (FZoneName[1] in ['I', 'X', 'V']); if not Result then Exit;
  i:=Pos(':', FZoneName); Result:=i>1; if not Result then Exit;
  FRailwayName:= Copy(FZoneName,1,i-1);
  i:=Pos('. ', FRailwayName);
  if i>0 then FRailwayName:= Copy(FRailwayName,i+2);
  ResourceToRawByteString(RES_RZD_ZONES, PChar(10), rr);
  Result:=rr<>''; if not Result then Exit;
  r:=rr;
  ra:=TRawUtf8List.Create;
  try
    ra.Text:=r;
    wn:=StringToUtf8(FRailwayName);
    rn:=StringToUtf8(FRegionName);
    for i:=0 to ra.Count-1 do begin
      flds:=CsvToRawUtf8DynArray(ra[i],'#');
      r:=TrimU(flds[5]);
      k:=PosEx(wn,r,1);
      if k>0 then k:=PosEx(rn,r,k);
      if k>0 then begin
        if ToInteger(flds[2],k) then FZoneID:=k;
        if ToInteger(flds[1],k) then FRegionID:=k;
        Break;
      end;
    end;
  finally
    ra.Free;
  end;
end;

function TEstimateRegion.ToDoc: Variant;
begin
  Result:=_obj([RegionIDFieldName,FRegionID, ZoneIDFiledName,FZoneID]);
  TDocVariantData(Result).AddValue(RegionNameFieldName, StringToUtf8(FRegionName));
  TDocVariantData(Result).AddValue(ZoneNameFiledName, StringToUtf8(FZoneName));
  TDocVariantData(Result).AddValue(RailwayNameFiledName, StringToUtf8(FRailwayName));
  TDocVariantData(Result).AddValue(IndustryFiledName, StringToUtf8(FIndustry));
  if FState<>'' then TDocVariantData(Result).AddValue(StateFieldName, StringToUtf8(FState));
end;

class function TEstimateRegion.Utf8RegionNameByID(const RName: RawUtf8; const Region: Word; const FromResource: Boolean): RawUtf8;
var r: RawUtf8; ra: TRawUtf8List; i: Integer; rr: RawByteString; s: string; rb: TRawUtf8DynArray;
begin
  Result:='';
  if Region=0 then Result:=''
  else if FromResource then begin
    ResourceToRawByteString(Utf8ToString(RName), PChar(10), rr);
    r:=rr;
  end else begin
    s:=Utf8ToString(RName);
    if FileExists(s) then r:=StringFromFile(s)
                     else Result:='';
  end;
  if r<>'' then begin
    ra:=TRawUtf8List.Create;
    try
      ra.Text:=r;
      for i:=0 to ra.Count-1 do begin
        r:=ra[i]; if r='' then Continue;
        SetLength(rb,0);
        CsvToRawUtf8DynArray(@r[1], rb, '#');
        if (Length(rb)>1) and (StrToIntDef(rb[1],0)=Region) then begin
          Result:=rb[0]; Break;
        end;
      end;
    finally
      ra.Free;
    end;
  end;
end;

class function TEstimateRegion.RailwayZoneNameByID(const RName: string; const Zone, Subzone: Word; const FromResource: Boolean): string;
var r,rz: RawUtf8; ra: TRawUtf8List; i,j: Integer; rr: RawByteString;
begin
  Result:='';
  if Zone=0 then Result:=''
  else if FromResource then begin
    ResourceToRawByteString(RName, PChar(10), rr);
    r:=rr;
  end else begin
    if FileExists(RName) then r:=StringFromFile(RName)
                         else Result:='';
  end;
  if r<>'' then begin
    ra:=TRawUtf8List.Create;
    try
      ra.Text:=r;
      if Subzone>0 then rz:=Format('#%3.3d#%3.3d#',[Zone,SubZone])
                   else rz:=Format('#%3.3d#',[Zone]);
      r:='';
      for i:=0 to ra.Count-1 do begin
        j:=PosEx(rz,ra[i]);
        if (j=7) or (j=8) then begin
          r:=ra[i]; Break;
        end;
      end;
      if r='' then Exit;
      ra.Clear;
      ra.SetText(r, '#');
      r:=ra[ra.Count-1];
      r:=Trim(r);
      Result:=Utf8ToString(r);
    finally
      ra.Free;
    end;
  end;
end;

class function TEstimateRegion.RailwayZoneStr(const RName: string; const Zone, Subzone: Word; const FromResource: Boolean): string;
begin
  Result:=RailwayZoneUTF8(RName,Zone,Subzone,FromResource);
end;

class function TEstimateRegion.RailwayZoneUTF8(const RName: string; const Zone, Subzone: Word; const FromResource: Boolean): RawUtf8;
var r,rz: RawUtf8; ra: TRawUtf8List; i,j: Integer; rr: RawByteString;
begin
  Result:='';
  if (Zone=0) or (Subzone=0) then Exit;
  if FromResource then begin
    ResourceToRawByteString(RName, PChar(10), rr);
    r:=rr;
  end else begin
    if FileExists(RName) then r:=StringFromFile(RName)
                         else Result:='';
  end;
  if r<>'' then begin
    ra:=TRawUtf8List.Create;
    try
      ra.Text:=r;
      if Subzone>0 then rz:=Format('#%3.3d#%3.3d#',[Zone,SubZone])
                   else rz:=Format('#%3.3d#',[Zone]);
      for i:=0 to ra.Count-1 do begin
        j:=PosEx(rz,ra[i]);
        if (j=7) or (j=8) then begin
          Result:=ra[i]; Break;
        end;
      end;
    finally
      ra.Free;
    end;
  end;
end;

{ TEstLinkResource }

procedure TEstLinkResource.From(LR: TEstLinkResource);
begin
  FGuid:=LR.GUID; FID:=LR.ID;
end;

procedure TEstLinkResource.Init(const AGuid: TGUID; const AID: Cardinal);
begin
  FGuid:=AGuid; FID:=AID;
end;

function TEstLinkResource.IsEqual(const LR: TEstLinkResource): Boolean;
begin
  Result:=IsEqualGuid(FGuid, LR.FGuid) and (FID=LR.ID);
end;

procedure TEstLinkResource.Init(const AID: Cardinal);
begin
  FGuid:=GUID_NULL; FID:=AID;
end;

procedure TEstLinkResource.SetGuid(const AValue: TGUID);
begin
  FGuid:=AValue;
end;

procedure TEstLinkResource.SetID(const AValue: Cardinal);
begin
  FID:=AValue;
end;

function TEstLinkResource.FromDoc(const PDoc: PDocVariantData): Boolean;
var i64: Int64; r: RawUtf8;
begin
  Result := (PDoc<>nil)
        and PDoc^.GetAsInt64('ID', i64) and (i64>=0);
  if Result then begin
    FID:=i64;
    if PDoc^.GetAsRawUtf8('GUID', r) then FGuid:=RawUtf8ToGuid(r)
                                     else FGuid:=GUID_NULL;
  end;
end;


function TEstLinkResource.ToDoc: Variant;
begin
  Result:=_Obj(['ID', FID]);
  if not IsNullGuid(FGuid) then TDocVariantData(Result).AddValue('GUID', GuidToRawUtf8(FGuid));
end;

initialization

  InitModule;

end.