Estimate/EstResourcesV3.pas - master - YakuninAV/Convertors

Estimate/EstResourcesV3.pas
964 строки31 KB
YakuninAV
begin with gitflick
31 июл 2026, 15:21
31 июл 2026, 15:211dc0fc6
unit EstResourcesV3;

{$I mormot.defines.inc}

interface

uses
{$IFDEF ISDELPHIXE2}
  SysUtils, Classes, Types, DateUtils,
{$ELSE}
  SysUtils, Classes, Types, DateUtils,
{$ENDIF}
  mormot.core.base, mormot.core.variants, mormot.core.os, mormot.core.unicode, mormot.core.interfaces,
  DBDIntfs, DBDStrUtils,
  EstTypes, EstIntfsV3, EstCyphersV3, EstPricesV3
  ;

type

  /// Класс реализующий интерфейс для работы с ресурсами расценок
  TEstResourceV3 = class(TInterfacedObject, IEstResourceV3)
  private
    function GetAverageTariff: Double;
    function GetCoefficient(Index: Integer): IEstCoefficientV3;
    function GetCoefficients: TEstCoefficientV3DynArray;
    function GetConsumption: Double;
    function GetConsumptionTotal: Double;
    function GetCount: Double;
    function GetCustom: Boolean;
    function GetCypher: string;
    function GetInflationRate(Index: Integer): IEstInflationRateV3;
    function GetInflationRates: TEstInflationRateV3DynArray;
    function GetLabor: Double;
    function GetName: string;
    function GetNum: Word;
    function GetNumRef: Word;
    function GetOwner: IEstItemV3;
    function GetPortage: IEstResourceV3;
    function GetPortageB: Currency;
    function GetPortageC: Currency;
    function GetPrice: IEstPriceV3;
    function GetPriceB: Currency;
    function GetPriceC: Currency;
    function GetPriceF: Currency;
    function GetPriceL: Currency;
    function GetResType: TEstimateResourceType;
    function GetUnaccounted: Boolean;
    function GetUnitsName: String;
    function GetUnspecified: Boolean;
    function GetWarehouseB: Currency;
    function GetWarehouseC: Currency;
    function GetGrossWeight: Double;
    function GetNetWeight: Double;
    procedure SetAverageTariff(Value: Double);
    procedure SetConsumption(Value: Double);
    procedure SetConsumptionTotal(Value: Double);
    procedure SetCount(Value: Double);
    procedure SetCustom(Value: Boolean);
    procedure SetCypher(Value: string);
    procedure SetLabor(Value: Double);
    procedure SetName(Value: string);
    procedure SetNum(Value: Word);
    procedure SetNumRef(Value: Word);
    procedure SetOwner(Value: IEstItemV3);
    procedure SetPortage(Value: IEstResourceV3);
    procedure SetPortageB(Value: Currency);
    procedure SetPortageC(Value: Currency);
    procedure SetPriceB(Value: Currency);
    procedure SetPriceC(Value: Currency);
    procedure SetPriceF(Value: Currency);
    procedure SetPriceL(Value: Currency);
    procedure SetResType(Value: TEstimateResourceType);
    function GetSalaryB: Currency;
    function GetSalaryC: Currency;
    function GetSalaryF: Currency;
    function GetSalaryL: Currency;
    procedure SetSalaryB(Value: Currency);
    procedure SetSalaryC(Value: Currency);
    procedure SetSalaryF(Value: Currency);
    procedure SetSalaryL(Value: Currency);
    procedure SetUnaccounted(Value: Boolean);
    procedure SetUnitsName(Value: string);
    procedure SetUnspecified(Value: Boolean);
    procedure SetWarehouseB(Value: Currency);
    procedure SetWarehouseC(Value: Currency);
    function GetID: Integer;
    procedure SetID(Value: Integer);
    function GetLinks: TEstLinkResourceDynArray;
    function GetCodeOKP: string;
    function GetCodeOKPD2: string;
    procedure SetCodeOKP(const Value: string);
    procedure SetCodeOKPD2(const Value: string);
    procedure SetGrossWeight(const Value: Double);
    procedure SetNetWeight(const Value: Double);
  strict protected
    function FromDocCoefficients(pDoc: PDocVariantData): Boolean;
    function FromDocRates(PDoc: PDocVariantData): Boolean;
    function FromDocPortage(PDoc: PDocVariantData): Boolean;
    function CheckCoefficientForUse(Coef: IEstCoefficientV3): Boolean;
  protected
    FID: Integer;
    FCodeOKP, FCodeOKPD2: string;
    FName, FCypher, FUnitsName: string;
    FNum, FNumRef: Word;
    FCount: Double;
    FConsumption,FConsumptionTotal, FLabour, FNetWeight, FGrossWeight: Double;
    FAverageTariff: Double;
    FCustom, FUnaccounted, FUnspecified: Boolean;
    FPriceF, FPriceL: Currency;
    FSalaryB, FSalaryC, FSalaryF, FSalaryL: Currency;
    FPortageB, FPortageC, FWarehouseB, FWarehouseC: Currency;
    FResType: TEstimateResourceType;
    FOwner: IEstItemV3;
    FCoefficients: TEstCoefficientV3DynArray;
    FInflationRates: TEstInflationRateV3DynArray;
    FPrice: IEstPriceV3;
    FPortage: IEstResourceV3;
    FLinks: TEstLinkResourceDynArray;
    FNotifier: IDBDNotifierV1;
    function Notify(const MsgKind: TDBDMessageKind; const MsgCode: Integer; const MsgText: string): Boolean;
  public
    /// Средний разряд работ
    property AverageTariff: Double read GetAverageTariff write SetAverageTariff;
    /// Код ОКП
    property CodeOKP: string read GetCodeOKP write SetCodeOKP;
    /// Код ОКРПД2
    property CodeOKPD2: string read GetCodeOKPD2 write SetCodeOKPD2;
    /// Поправочные коэффициенты применённые к ресурсу
    property Coefficient[Index: Integer]: IEstCoefficientV3 read GetCoefficient;
    /// Массив коэффицентов, применённых к ресурсу
    property Coefficients: TEstCoefficientV3DynArray read GetCoefficients;
    /// Расход ресурса на единицу измерения
    property Consumption: Double read GetConsumption write SetConsumption;
    /// Полный расход ресурса
    // для подчинённых позиций на объём расценки
    // для свободных ресурсов определяется сметчиком
    property ConsumptionTotal: Double read GetConsumptionTotal write SetConsumptionTotal;
    // Количество рабочих/машинистов
    property Count: Double read GetCount write SetCount;
    /// Признак прайсовой позиции
    property Custom: Boolean read GetCustom write SetCustom;
    /// Шифр ресурса
    property Cypher: string read GetCypher write SetCypher;
    /// Индексы пересчёта применённые к ресурсу
    property InflationRate[Index: Integer]: IEstInflationRateV3 read GetInflationRate;
    /// Индексы пересчёта применённые к ресурсу
    property InflationRates: TEstInflationRateV3DynArray read GetInflationRates;
    /// Затраты труда
    property Labor: Double read GetLabor write SetLabor;
    /// Наименование ресурса
    property Name: string read GetName write SetName;
    /// Номер ресурса
    property Num: Word read GetNum write SetNum;
    /// Ссылка на номер ресурса в списке, к которому относится данный ресурс
    property NumRef: Word read GetNumRef write SetNumRef;
    /// Указатель на интерфейс для работы с информацией о позиции, содержащей ресурс
    property Owner: IEstItemV3 read GetOwner write SetOwner;
    /// Инегрированный показатель стоимости ресурса
    property Price: IEstPriceV3 read GetPrice;
    /// Транспорт, используемый для доставки ресурса
    property Portage: IEstResourceV3 read GetPortage write SetPortage;
    /// Транспортные расходы в базисных ценах
    property PortageB: Currency read GetPortageB write SetPortageB;
    /// Транспортные расходы в текущих ценах
    property PortageC: Currency read GetPortageC write SetPortageC;
    /// Стоимость ресурса в базисном уровне цен
    property PriceB: Currency read GetPriceB write SetPriceB;
    /// Стоимость ресурса в текущем уровне цен
    property PriceC: Currency read GetPriceC write SetPriceC;
    /// Стоимость ресурса фактическая
    property PriceF: Currency read GetPriceF write SetPriceF;
    /// Стоимость ресурса местная
    property PriceL: Currency read GetPriceL write SetPriceL;
    /// Тип ресурса
    property ResType: TEstimateResourceType read GetResType write SetResType;
    /// Заработная плата машинистов в базисных ценах
    property SalaryB: Currency read GetSalaryB write SetSalaryB;
    /// Заработная плата машинистов в текущих ценах
    property SalaryC: Currency read GetSalaryC write SetSalaryC;
    /// Заработная плата машинистов фактическая
    property SalaryF: Currency read GetSalaryF write SetSalaryF;
    /// Заработная плата машинистов местная
    property SalaryL: Currency read GetSalaryL write SetSalaryL;
    /// Признак игнорирования в расчете стоимости
    property Unaccounted: Boolean read GetUnaccounted write SetUnaccounted;
    /// Единица измерения объёма
    property UnitsName: string read GetUnitsName write SetUnitsName;
    /// Признак обобщенного наименования
    property Unspecified: Boolean read GetUnspecified write SetUnspecified;
    property NetWeight: Double read GetNetWeight write SetNetWeight;
    property GrossWeight: Double read GetGrossWeight write SetGrossWeight;
    /// Заготовительно-складские расходы в базисном уровне цен
    property WarehouseB: Currency read GetWarehouseB write setWarehouseB;
    /// Заготовительно-складские расходы в текущем уровне цен
    property WarehouseC: Currency read GetWarehouseC write setWarehouseC;
    /// конструктор
    /// Уникальный номер ресурса в рамках сметы
    property ID: Integer read GetID write SetID;
    /// Связи с другими ресурсами
    property Links: TEstLinkResourceDynArray read GetLinks;
    constructor Create(const rt: TEstimateResourceType; const aName: string; const aNum: Word=0); overload;
    constructor Create(const PDoc: PDocVariantData); overload;
    constructor CreateEquipment(const aCyp, aName: string; const aNum: Word=0);
    constructor CreateMachines(const aCyp, aName: string; const aNum: Word=0);
    constructor CreateMachinist(const aCyp, aName: string; const aNum: Word=0);
    constructor CreateMaterial(const aCyp, aName: string; const aNum: Word=0);
    constructor CreatePortage(const aCyp, aName: string; const aNum: Word=0);
    constructor CreateWorker(const aCyp, aName: string; const aNum: Word=0);
    class function NewResource(const rt: TEstimateResourceType; const aCyp,aName: string; const aNum: Word=0): IEstResourceV3;
    /// Функция добавляет индекс пересчёта
    function AddIndex(Idx: IEstInflationRateV3): Integer;
    /// Функция добавляет поправочный коэффициент, применённый к ресурсу
    function AddCoefficient(Coef: IEstCoefficientV3): Integer;
    ///
    function AddLink(const Value: TEstLinkResource): Integer;
    /// Функция добавляет к элементу стоимости работ ресурса значение
    function AddPriceItem(const Value: Currency; const ct:TEstimateCostType; const pt: TEstimatePriceItemType): Integer;
    /// Функция возвращает количество поправочных коэффициентов, применённых к ресурсу
    function CoefficientsCount: Integer;
    /// Функция возвращает количество индексов, применённых к ресурсу
    function InflationRatesCount: Integer;
    /// Функция загружает информацию из JSON-документа
    function FromDoc(const PDoc: PDocVariantData): Boolean;
    /// Функция возвращает документ JSON с информацией о ресурсе
    function ToDoc: Variant;
  end;

  /// Класс, реализующий интерфейс для работы с ресурсом-зарплата
  TEstSalaryV3 = class(TEstResourceV3, IEstSalaryV3)
  private
    function GetIsMachinist: Boolean;
  public
    property isMachinist: Boolean read GetIsMachinist;
    constructor Create(const isMch: Boolean; const aName: string; const Trf: Double; const aNum: Word=0); overload;
    constructor CreateMachinist(const aName: string; const Trf: Double; const aNum: Word=0); overload;
    constructor CreateWorker(const aName: string; const Trf: Double; const aNum: Word=0); overload;
  end;

  /// Класс, реализующий интерфейс для работы с ресурсом машины и механизмы
  TEstMachineV3 = class(TEstResourceV3)
  private
    function GetMachinist: IEstResourceV3;
    procedure SetMachinist(Value: IEstResourceV3);
  protected
    FMachinist: IEstResourceV3;
  public
    property Machinist : IEstResourceV3 read GetMachinist write SetMachinist;
  end;

  /// Класс, реализующий интерфейс для работы с ресурсом перевозка
  TEstPortageV3 = class(TEstResourceV3)
  public
    constructor Create(const aCyp, aName: string; const aNum: Word=0); overload;
    constructor Create(const PDoc: PDocVariantData); overload;
  end;

implementation

uses
  EstItemsV3
  ;

{ TEstResource }

function TEstResourceV3.AddCoefficient(Coef: IEstCoefficientV3): Integer;
var i: Integer; cf: IEstCoefficientV3; cv: IEstCoefficientValueV3; f: Boolean;
begin
  Result:=-2;
  if Coef=nil then Exit;
  if Coef.Category=eccFinal then begin
    for i := 0 to High(FCoefficients) do
      if FCoefficients[i].Category=eccFinal then begin
        FCoefficients[i]:=Coef; Result:=i; Exit;
      end
  end else if Coef.Category=eccRegular then begin
    for i := 0 to High(FCoefficients) do begin
      cf:=FCoefficients[i];
      if cf.Category=eccRegular then begin
        f:=(cf.Name<>'') and (Coef.Name<>'') and (cf.Name=Coef.Name);
        if not f then f:=(cf.Reason<>'') and (Coef.Reason<>'') and (cf.Reason=Coef.Reason);
        if f then begin
          for cv in Coef.CoefValues do
            if not cv.IsOne then cf.AddOrUpdateCoefValue(cv);
            Result:=i;
          Exit;
        end;
      end;
    end;
  end;
  Result:=Length(FCoefficients);
  SetLength(FCoefficients, Result+1);
  FCoefficients[Result]:=Coef;
end;

function TEstResourceV3.AddIndex(Idx: IEstInflationRateV3): Integer;
begin
  if Idx<>nil then begin
    Result:= Length(FInflationRates);
    SetLength(FInflationRates, Result+1);
    FInflationRates[Result]:=Idx;
  end else Result:=-1
end;

function TEstResourceV3.AddLink(const Value: TEstLinkResource): Integer;
var t: TEstLinkResource;
begin
  Result:=-1;
  for t in FLinks do
    if t.IsEqual(Value) then Exit;
  Result:=Length(FLinks);
  SetLength(FLinks, Result+1);
  FLinks[Result]:=Value;
end;

function TEstResourceV3.AddPriceItem(const Value: Currency; const ct: TEstimateCostType; const pt: TEstimatePriceItemType): Integer;
begin
  FPrice.PriceValue[ct,pt]:=Value;
  Result:=FPrice.Count;
end;

function TEstResourceV3.CheckCoefficientForUse(Coef: IEstCoefficientV3): Boolean;
begin
  Result:=False;
  if Coef.IsVolume then Result:=True
  else begin
    case FResType of
      ertWorker: Result:=Coef.IndexOfValueTarget(evtWorkerSalary)>0;
      ertMachinist: Result:=Coef.IndexOfValueTarget(evtMachinistSalary)>0;
      ertMachines: Result:=Coef.IndexOfValueTarget(evtMachines)>0;
      ertMaterial: Result:=Coef.IndexOfValueTarget(evtMaterial)>0;
      ertEquipment: Result:=Coef.IndexOfValueTarget(evtEquipment)>0;
      ertPortage: Result:=Coef.IndexOfValueTarget(evtPortage)>0;
      ertUndefined: Result:=false;
    end;
  end;
end;

function TEstResourceV3.CoefficientsCount: Integer;
begin
  Result:=Length(FCoefficients);
end;

constructor TEstResourceV3.Create(const PDoc: PDocVariantData);
begin
  inherited Create;
  if not FromDoc(PDoc) then begin
    SetResType(ertUndefined);
    if (PDoc<>nil) then begin
      if PDoc^.Count<>0 then SetName(Utf8ToString(PDoc^.ToJson))
                        else SetName('Invalid PDoc');
    end;
  end;
end;

constructor TEstResourceV3.CreateEquipment(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertEquipment, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.CreateMachines(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertMachines, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.CreateMachinist(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertMachinist, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.CreateMaterial(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertMaterial, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.CreatePortage(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertPortage, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.CreateWorker(const aCyp, aName: string; const aNum: Word);
begin
  Create(ertWorker, aName, aNum);
  SetCypher(aCyp);
end;

constructor TEstResourceV3.Create(const rt: TEstimateResourceType; const aName: string; const aNum: Word);
begin
  inherited Create();
  SetNum(aNum); SetName(aName);
  SetResType(rt);
  SetCount(0);
  SetLength(FCoefficients,0); SetLength(FInflationRates,0);
  FPrice:=TEstPriceV3.Create;
end;

function TEstResourceV3.GetAverageTariff: Double;
begin
  Result:=FAverageTariff;
end;

function TEstResourceV3.GetCodeOKP: string;
begin
  Result:=FCodeOKP;
end;

function TEstResourceV3.GetCodeOKPD2: string;
begin
  Result:=FCodeOKPD2;
end;

function TEstResourceV3.GetCoefficient(Index: Integer): IEstCoefficientV3;
begin
  if (Low(FCoefficients)<=Index)  and (High(FCoefficients)>=Index) then Result:=FCoefficients[Index] else Result:=nil;
end;

function TEstResourceV3.GetCoefficients: TEstCoefficientV3DynArray;
begin
  Result:=FCoefficients;
end;

function TEstResourceV3.GetConsumption: Double;
begin
  Result:=FConsumption;
end;

function TEstResourceV3.GetConsumptionTotal: Double;
begin
  Result:=FConsumptionTotal;
end;

function TEstResourceV3.GetCount: Double;
begin
  Result:=FCount;
end;

function TEstResourceV3.GetCustom: Boolean;
begin
  Result:=FCustom;
end;

function TEstResourceV3.GetCypher: string;
begin
  Result:=FCypher;
end;

function TEstResourceV3.GetGrossWeight: Double;
begin
  Result:=FGrossWeight;
end;

function TEstResourceV3.GetID: Integer;
begin
  result:=FID;
end;

function TEstResourceV3.GetInflationRate(Index: Integer): IEstInflationRateV3;
begin
  if (Low(FInflationRates)<=Index)  and (High(FInflationRates)>=Index) then Result:=FInflationRates[Index] else Result:=nil;
end;

function TEstResourceV3.GetInflationRates: TEstInflationRateV3DynArray;
begin
  Result:=FInflationRates;
end;

function TEstResourceV3.GetLabor: Double;
begin
  Result:=FLabour;
end;

function TEstResourceV3.GetLinks: TEstLinkResourceDynArray;
begin
  Result:=FLinks;
end;

function TEstResourceV3.GetName: string;
begin
  Result:=FName;
end;

function TEstResourceV3.GetNetWeight: Double;
begin
  REsult:=FNetWeight;
end;

function TEstResourceV3.GetNum: Word;
begin
  Result:=FNum;
end;

function TEstResourceV3.GetNumRef: Word;
begin
  Result:=FNumRef;
end;

function TEstResourceV3.GetOwner: IEstItemV3;
begin
  Result:=FOwner;
end;

function TEstResourceV3.GetPortage: IEstResourceV3;
begin
  Result:=FPortage;
end;

function TEstResourceV3.GetPortageB: Currency;
begin
  Result:=FPrice.PriceValue[ectBase, epiPortage];
end;

function TEstResourceV3.GetPortageC: Currency;
begin
  Result:=FPrice.PriceValue[ectCurr, epiPortage];
end;

function TEstResourceV3.GetPrice: IEstPriceV3;
begin
  Result:=FPrice;
end;

function TEstResourceV3.GetPriceB: Currency;
begin
//  Result:=FPriceB;
  Result:=FPrice.PriceValue[ectBase, epiPrice];
end;

function TEstResourceV3.GetPriceC: Currency;
begin
//  Result:=FPriceC;
  Result:=FPrice.PriceValue[ectCurr, epiPrice];
end;

function TEstResourceV3.GetPriceF: Currency;
begin
  Result:=FPriceF;
end;

function TEstResourceV3.GetPriceL: Currency;
begin
  Result:=FPriceL;
end;

function TEstResourceV3.GetRestype: TEstimateResourceType;
begin
  Result:=FResType;
end;

function TEstResourceV3.GetSalaryB: Currency;
begin
  Result:=FSalaryB;
end;

function TEstResourceV3.GetSalaryC: Currency;
begin
  Result:=FSalaryC;
end;

function TEstResourceV3.GetSalaryF: Currency;
begin
  Result:=FSalaryF;
end;

function TEstResourceV3.GetSalaryL: Currency;
begin
  Result:=FSalaryL;
end;

function TEstResourceV3.GetUnaccounted: Boolean;
begin
  Result:=FUnaccounted;
end;

function TEstResourceV3.GetUnitsName: String;
begin
  Result:=FUnitsName;
end;

function TEstResourceV3.GetUnspecified: Boolean;
begin
  Result:= FUnspecified;
end;

function TEstResourceV3.GetWarehouseB: Currency;
begin
  Result:=FPrice.PriceValue[ectBase, epiWarehouse];
end;

function TEstResourceV3.GetWarehouseC: Currency;
begin
  Result:=FPrice.PriceValue[ectCurr, epiWarehouse];
end;

function TEstResourceV3.InflationRatesCount: Integer;
begin
  Result:=Length(FInflationRates);
end;

class function TEstResourceV3.NewResource(const rt: TEstimateResourceType; const aCyp,aName: string; const aNum: Word): IEstResourceV3;
begin
  case rt of
    ertWorker: Result:= TEstResourceV3.CreateWorker(aCyp, aName, aNum);
    ertMachinist: Result:=TEstResourceV3.CreateMachinist(aCyp, aName, aNum);
    ertMachines: Result:=TEstResourceV3.CreateMachines(aCyp, aName, aNum);
    ertMaterial: Result:=TEstResourceV3.CreateMaterial(aCyp, aName, aNum);
    ertEquipment: Result:=TEstResourceV3.CreateEquipment(aCyp, aName, aNum);
    ertPortage: Result:=TEstResourceV3.CreatePortage(aCyp, aName, aNum);
    ertOther: begin Result:=TEstResourceV3.Create(rt, aName, aNum); Result.Cypher:=aCyp; end;
    ertUndefined: Result:=nil;
  end;
end;

function TEstResourceV3.Notify(const MsgKind: TDBDMessageKind; const MsgCode: Integer; const MsgText: string): Boolean;
begin
  if Assigned(FNotifier) then Result:= FNotifier.Log(MsgKind, MsgCode, MsgText);
end;

procedure TEstResourceV3.SetAverageTariff(Value: Double);
begin
  FAverageTariff:=Value;
end;

procedure TEstResourceV3.SetCodeOKP(const Value: string);
begin
  FCodeOKP:=Value;
end;

procedure TEstResourceV3.SetCodeOKPD2(const Value: string);
begin
  FCodeOKPD2:=Value;
end;

procedure TEstResourceV3.SetConsumption(Value: Double);
begin
  FConsumption:=Value;
end;

procedure TEstResourceV3.SetConsumptionTotal(Value: Double);
begin
  FConsumptionTotal:=Value;
end;

procedure TEstResourceV3.SetCount(Value: Double);
begin
  FCount:=Value;
end;

procedure TEstResourceV3.SetCustom(Value: Boolean);
begin
  FCustom:=Value;
end;

procedure TEstResourceV3.SetCypher(Value: string);
begin
  FCypher:=DBDTrim(Value);
end;

procedure TEstResourceV3.SetGrossWeight(const Value: Double);
begin
  FGrossWeight:=Value;
end;

procedure TEstResourceV3.SetID(Value: Integer);
begin
  FID:=Value;
end;

procedure TEstResourceV3.SetLabor(Value: Double);
begin
  FLabour:=Value;
end;

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

procedure TEstResourceV3.SetNetWeight(const Value: Double);
begin
  FNetWeight:=Value;
end;

procedure TEstResourceV3.SetNum(Value: Word);
begin
  FNum:=Value;
end;

procedure TEstResourceV3.SetNumRef(Value: Word);
begin
  FNumRef:=Value;
end;

procedure TEstResourceV3.SetOwner(Value: IEstItemV3);
begin
  SetWeak(@FOwner, Value);
end;

procedure TEstResourceV3.SetPortage(Value: IEstResourceV3);
begin
  FPortage:=Value;
end;

procedure TEstResourceV3.SetPortageB(Value: Currency);
begin
  FPrice.PriceValue[ectBase, epiPortage]:=Value;
end;

procedure TEstResourceV3.SetPortageC(Value: Currency);
begin
  FPrice.PriceValue[ectCurr, epiPortage]:=Value;
end;

procedure TEstResourceV3.SetPriceB(Value: Currency);
begin
  FPrice.PriceValue[ectBase, epiPrice]:=Value;
  FPrice.PriceValue[ectOneBase, epiPrice]:=Value;
end;

procedure TEstResourceV3.SetPriceC(Value: Currency);
begin
  FPrice.PriceValue[ectCurr, epiPrice]:=Value;
  FPrice.PriceValue[ectOneCurr, epiPrice]:=Value;
end;

procedure TEstResourceV3.SetPriceF(Value: Currency);
begin
  FPriceF:=Value;
end;

procedure TEstResourceV3.SetPriceL(Value: Currency);
begin
  FPriceL:=Value;
end;

procedure TEstResourceV3.SetResType(Value: TEstimateResourceType);
begin
  FResType:=Value;
end;

procedure TEstResourceV3.SetSalaryB(Value: Currency);
begin
  FSalaryB:=Value;
end;

procedure TEstResourceV3.SetSalaryC(Value: Currency);
begin
  FSalaryC:=Value;
end;

procedure TEstResourceV3.SetSalaryF(Value: Currency);
begin
  FSalaryF:=Value;
end;

procedure TEstResourceV3.SetSalaryL(Value: Currency);
begin
  FSalaryL:=Value;
end;

procedure TEstResourceV3.SetUnaccounted(Value: Boolean);
begin
  FUnaccounted:=Value;
end;

procedure TEstResourceV3.SetUnitsName(Value: string);
begin
  FUnitsName:=Value;
end;

procedure TEstResourceV3.SetUnspecified(Value: Boolean);
begin
  FUnspecified:=Value;
end;

procedure TEstResourceV3.SetWarehouseB(Value: Currency);
begin
  FPrice.PriceValue[ectBase, epiWarehouse]:=Value;
end;

procedure TEstResourceV3.SetWarehouseC(Value: Currency);
begin
  FPrice.PriceValue[ectCurr, epiWarehouse]:=Value;
end;

function TEstResourceV3.FromDoc(const PDoc: PDocVariantData): Boolean;
var rCyp, rName, rUName, r: RawUtf8; i: Integer; iCur: Int64; cCur: Currency absolute iCur; p: PDocVariantData; t:TEstLinkResource;
begin
  Result := (PDoc<>nil) and (PDoc^.Kind=dvObject)
        and PDoc^.GetAsRawUtf8('cyp',rCyp)
        and PDoc^.GetAsRawUtf8('nam',rName)
        and PDoc^.GetAsRawUtf8('unt',rUName)
        and PDoc^.GetAsInt64('prb', iCur)
        and PDoc^.GetAsDouble('qty', FConsumption)
        and PDoc^.GetAsInteger('typ', i)
        ;
  if not Result then begin
    Notify(dmkErrorInfo, 0, 'Неверный формат JSON-документ для ресурса: ' + Utf8ToString(PDoc^.ToJSON));
    Exit;
  end;
  FCypher := Utf8ToString(rCyp);
  FName := Utf8ToString(rName);
  FUnitsName := Utf8ToString(rUName);
  FResType := TEstimateResourceType(i);
  SetPriceB(cCur);
  if PDoc^.GetAsRawUtf8('cod',r) then FCodeOKP:=Utf8ToString(r) else FCodeOKP:='';
  if PDoc^.GetAsRawUtf8('cd2',r) then FCodeOKPD2:=Utf8ToString(r) else FCodeOKPD2:='';
  if PDoc^.GetAsInteger('num', i) then FNum := i else FNum := 0;
  if PDoc^.GetAsInteger('ref', i) then FNumRef := i else FNumRef := 0;
  if not PDoc^.GetAsDouble('cnt',FCount) then FCount:=1.0;
  if not PDoc^.GetAsDouble('tot', FConsumptionTotal) then FConsumptionTotal := 0.;
  if not PDoc^.GetAsDouble('ntw', FNetWeight) then FNetWeight := 0.;
  if not PDoc^.GetAsDouble('grw', FGrossWeight) then FGrossWeight := 0.;

  if not PDoc^.GetAsDouble('lab', FLabour) then FLabour := 0;
  if not PDoc^.GetAsBoolean('una', FUnaccounted) then FUnaccounted := False;
  if not PDoc^.GetAsBoolean('uns', FUnspecified) then FUnspecified := False;
  if not PDoc^.GetAsInteger('rid',FID) then FID:=0;

  p:=pDoc^.GetAsDocVariantSafe('cfs');
  if (p<>nil) and (p^.Count>0) then Result:=FromDocCoefficients(p);
  if Result then begin
    p:=PDoc^.GetAsDocVariantSafe('prt');
    if (p<>nil) and (p^.Count>0) and (p^.Kind=dvObject) then begin
    end;
  end;
  if Result then begin
    p:=pDoc^.GetAsDocVariantSafe('lnk');
    if p^.Kind=dvArray then begin
      SetLength(FLinks,p^.Count);
      for i := 0 to p^.Count-1 do
        FLinks[i].FromDoc(p^._[i]);
    end;
  end;
end;

function TEstResourceV3.FromDocCoefficients(pDoc: PDocVariantData): Boolean;
var i: Integer; coef: IEstCoefficientV3;
begin
  Result := True; if (pDoc=nil) or (pDoc^.Count=0) then Exit;
  Result := (pDoc^.Kind=dvArray); if not Result then Exit;
  for i := 0 to pDoc^.Count-1 do begin
//    coef := TEstCoefficient.Create(eckResource,'',0);
    if coef.FromDoc(pDoc^._[i]) then Result := (AddCoefficient(coef)>=0)
                                else Result := False;
    if not Result then Break;
  end;
end;

function TEstResourceV3.FromDocPortage(PDoc: PDocVariantData): Boolean;
begin
  Result := True; if (pDoc=nil) or (pDoc^.Count=0) then Exit;
  FPortage:=nil;
end;

function TEstResourceV3.FromDocRates(PDoc: PDocVariantData): Boolean;
var i: Integer; r: IEstInflationRateV3;
begin
//  Result := True; if (pDoc=nil) or (pDoc^.Count=0) then Exit;
//  Result := (pDoc^.Kind=dvArray); if not Result then Exit;
//  for i := 0 to PDoc^.Count-1 do begin
//    r := TEstInflationRate.Create('');
//    if r.FromDoc(PDoc^._[i]) then Result := (AddInflationRate(r)>=0)
//                             else REsult := False;
//    if not Result then Break;
//  end;
end;

function TEstResourceV3.ToDoc: Variant;
var i64: Int64; c: Currency absolute i64; a,v: Variant;  i: Integer;
    idx: IEstInflationRateV3; coef: IEstCoefficientV3; r: TEstLinkResource;
begin
  Result:=_Obj([]);
  TDocVariantData(Result).AddValue('cyp', StringToUTF8(FCypher));
  TDocVariantData(Result).AddValue('cod', StringToUTF8(FCodeOKP));
  TDocVariantData(Result).AddValue('cd2', StringToUTF8(FCodeOKPD2));
  TDocVariantData(Result).AddValue('nam', StringToUTF8(FName));
  TDocVariantData(Result).AddValue('unt', StringToUTF8(FUnitsName));
  TDocVariantData(Result).AddValue('num', FNum);
  TDocVariantData(Result).AddValue('ref', FNumRef);
  TDocVariantData(Result).AddValue('qty', FConsumption);
  TDocVariantData(Result).AddValue('tot', FConsumptionTotal);
  if FGrossWeight<>0.0 then TDocVariantData(Result).AddValue('grw', FGrossWeight);
  if FGrossWeight<>0.0 then TDocVariantData(Result).AddValue('ntw', FNetWeight);
  TDocVariantData(Result).AddValue('cnt', FCount);
  c:=GetPriceB; TDocVariantData(Result).AddValue('prb', i64);
  c:=GetPriceC; TDocVariantData(Result).AddValue('prc', i64);
  TDocVariantData(Result).AddValue('lab', FLabour);
  TDocVariantData(Result).AddValue('cst', FCustom);
  TDocVariantData(Result).AddValue('una', FUnaccounted);
  TDocVariantData(Result).AddValue('uns', FUnspecified);
  TDocVariantData(Result).AddValue('typ', Ord(FResType));
  TDocVariantData(Result).AddValue('rid', FID);
  v:=FPrice.ToDoc; TDocVariantData(Result).AddValue('price', v); TDocVariantData(v).Clear;
  a:=_Arr([]);
  for idx in FInflationRates do begin
    v:=idx.ToDoc; TDocVariantData(a).AddItem(v); TDocVariantData(v).Clear;
  end;
  TDocVariantData(Result).AddValue('idx', a); TDocVariantData(a).Clear;
  for coef in FCoefficients do begin
    if Coef=nil then Continue;
    v:=coef.ToDoc; TDocVariantData(a).AddItem(v); TDocVariantData(v).Clear;
  end;
  TDocVariantData(Result).AddValue('cfs', a); TDocVariantData(a).Clear;
  for r in FLinks do begin
    v:=r.ToDoc; TDocVariantData(a).AddItem(v); TDocVariantData(v).Clear;
  end;
  TDocVariantData(Result).AddValue('lnk', a); TDocVariantData(a).Clear;
end;

{ TEstPortageV3 }

constructor TEstPortageV3.Create(const PDoc: PDocVariantData);
begin

end;

constructor TEstPortageV3.Create(const aCyp, aName: string; const aNum: Word);
begin
  inherited Create(ertPortage, aName, aNum);
  SetCypher(aCyp);
end;

{ TEstMachineV3 }

function TEstMachineV3.GetMachinist: IEstResourceV3;
begin
  Result:=FMachinist;
end;

procedure TEstMachineV3.SetMachinist(Value: IEstResourceV3);
begin
  FMachinist:=Value;
end;

{ IEstSalaryV3 }

constructor TEstSalaryV3.Create(const isMch: Boolean; const aName: string; const Trf: Double; const aNum: Word);
begin
  if isMch then CreateMachinist(aName, Trf, aNum)
           else CreateWorker(aName, Trf, aNum);
end;

constructor TEstSalaryV3.CreateMachinist(const aName: string; const Trf: Double; const aNum: Word);
begin
  inherited Create(ertMachinist, aName, aNum);
  FAverageTariff:=Trf;
end;

constructor TEstSalaryV3.CreateWorker(const aName: string; const Trf: Double; const aNum: Word);
begin
  inherited Create(ertWorker, aName, aNum);
  FAverageTariff:=Trf;
end;

function TEstSalaryV3.GetIsMachinist: Boolean;
begin
  Result:=(FResType=ertMachinist);
end;

end.