unit uHeoObj_Vyroba;
{$RTTI EXPLICIT METHODS([vcPublic, vcPublished]) FIELDS([vcPrivate, vcProtected, vcPublic, vcPublished]) PROPERTIES([vcPublic, vcPublished])}


interface
{$I 'GlobalDefs.inc'}

uses
  System.Generics.Collections,
  MVCFramework.Serializer.Commons,
  MVCFramework.ActiveRecord,
  MVCFramework.Nullables,
  MVCFramework.Swagger.Commons,
  helTabsBIDs,
  uHeoObj_Base;

const
{$I globalConsts.inc}
  tblKategKJ = '[dbo].[TabKategKontJed]';

type
  TVyrobaNadrizenePrikazy = class(THeliosObjekty)
   private
    FIDPrikaz: integer;
    FIDPrikazVyssi: integer;
    FMnozstvi: Extended;
    FKryteMnozstvi: Extended;
    FPoziceKV: NullableString;
    FIDDilecVyssi: NullableInt32;
    FSZDilecVyssi: NullableString;
    FRegCisDilecVyssi: NullableString;
    FNazev1Vyssi: NullableString;
    FIDDilecNizsi: NullableInt32;
    FSZDilecNizsi: NullableString;
    FRegCisDilecNizsi: NullableString;
    FNazev1Nizsi: NullableString;
   public
    constructor Create; // nastaveni Default hodnot

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID vyššího výrobního příkazu', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('IDPrikazVyssi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikazVyssi', 'ID vyššího výrobního příkazu', true, false)]
    property IDPrikazVyssi: integer read FIDPrikazVyssi write FIDPrikazVyssi;

    [MVCColumn('Mnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnozstvi', 'Množství', true, false)]
    property Mnozstvi: Extended read FMnozstvi write FMnozstvi;

    [MVCColumn('KryteMnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'KryteMnozstvi', 'Množství', true, false)]
    property KryteMnozstvi: Extended read FKryteMnozstvi write FKryteMnozstvi;

    [MVCColumn('PoziceKV')]
    [MVCSwagJsonSchemaField(stString, 'PoziceKV', 'Pozice KV', false, true, 1, 100)]
    property PoziceKV: NullableString read FPoziceKV write FPoziceKV;

    [MVCColumn('IDDilecVyssi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDDilecVyssi', 'ID dílce vyššího výrobního příkazu', false, true)]
    property IDDilecVyssi: NullableInt32 read FIDDilecVyssi write FIDDilecVyssi;

    [MVCColumn('SkupZboV')]
    [MVCSwagJsonSchemaField(stString, 'SkupZboV', 'Skupina karet vyššího dílce', false, true, 0, 3)]
    property SZDilecVyssi: NullableString read FSZDilecVyssi write FSZDilecVyssi;

    [MVCColumn('RegCisV')] // nazev dle SELECTu
    [MVCSwagJsonSchemaField(stString, 'RegCisV', 'Registrační číslo vyššího dílce', false, true, 0, 30)]
    property RegCisDilecVyssi: NullableString read FRegCisDilecVyssi write FRegCisDilecVyssi;

    [MVCColumn('Nazev1V')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1V', 'Název vyššího dílce', false, true, 0, 100)]
    property Nazev1Vyssi: NullableString read FNazev1Vyssi write FNazev1Vyssi;

    [MVCColumn('IDDilecNizsi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDDilecNizsi', 'ID dílce ni6šího výrobního příkazu', false, true)]
    property IDDilecNizsi: NullableInt32 read FIDDilecNizsi write FIDDilecNizsi;

    [MVCColumn('SkupZboN')]
    [MVCSwagJsonSchemaField(stString, 'SkupZboN', 'Skupina karet vyššího dílce', false, true, 0, 3)]
    property SZDilecNizsi: NullableString read FSZDilecNizsi write FSZDilecNizsi;

    [MVCColumn('RegCisN')] // nazev dle SELECTu
    [MVCSwagJsonSchemaField(stString, 'RegCisN', 'Registrační číslo vyššího dílce', false, true, 0, 30)]
    property RegCisDilecNizsi: NullableString read FRegCisDilecNizsi write FRegCisDilecNizsi;

    [MVCColumn('Nazev1N')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1N', 'Název vyššího dílce', false, true, 0, 100)]
    property Nazev1Nizsi: NullableString read FNazev1Nizsi write FNazev1Nizsi;
  end;


  TMaterialPrikazu_Cols = (clMnozstviOdvedene, clMnozNevydane);
  [MVCNameCase(ncLowerCase)]
  TMaterialPrikazu = class(THeliosObjekty)
   private
//    FID: integer;
    FBarcode: string;
    FIDPrikaz: integer;
    FDoklad: integer;
    FIDOdchylkyOd: NullableInt32;
    FIDOdchylkyDo: NullableInt32;
    FIDPracoviste: NullableInt32;
{$IFDEF CUSTOM_CTRL_Rootvin}
    FTypDilce: NullableString;
{$ENDIF}
    FSklad: string;
    FVychoziSklad: string;
    FRezijniMat: boolean;
    FPrednastaveno: boolean;
    FPredzpracovano: boolean;
    FVyssi: integer;
    FSZVyssi: string;
    FRegCisVyssi: string;
    FNizsi: integer;
    FSZNizsi: string;
    FRegCisNizsi: string;
    FNazev1Nizsi: string;
    FPozice: string;
    FOperace: string;
    FSpotRozmer: string;
    FFixniMnozstvi: Extended;
    FMnozstvi: Extended;
    FProcZtrat: Extended;
    FmnozstviSeZtratou: Extended;
    FMnozstviZadane: Extended;
    FMnozstviNevydane: Extended;
    FVydanoRefMnoz: Extended;
    FRefMnoz: Extended;
    FPrirez: Extended;
    FMnoz_nepotrebne: Extended;
    FMnoz_skut_realizovane: Extended;
    FMnoz_odv: Extended;
    procedure WritePropReadOnlySingle(index: TMaterialPrikazu_Cols; Value: Extended);
    function ReadPropSingle(index: TMaterialPrikazu_Cols): Extended;
   public
    constructor Create; // nastaveni Default hodnot
{
    [MVCColumn('ID')]
//    [MVCTableField('ID', [foPrimaryKey])]
    [MVCSwagJsonSchemaField(stInteger, 'ID', 'ID kontrolního postupu', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property ID: integer read FID write FID;
}
    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID výrobního příkazu', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('Doklad')]
    [MVCSwagJsonSchemaField(stInteger, 'Doklad', 'ID výrobního příkazu', true, false)]
    property Doklad: integer read FDoklad write FDoklad;

    [MVCColumn('IDOdchylkyOd')]
    [MVCSwagJsonSchemaField(stInteger, 'IDOdchylkyOd', 'ID odchylky od', false, true)]
    property IDOdchylkyOd: NullableInt32 read FIDOdchylkyOd write FIDOdchylkyOd;

    [MVCColumn('IDOdchylkyDo')]
    [MVCSwagJsonSchemaField(stInteger, 'IDOdchylkyDo', 'ID odchylky do', false, true)]
    property IDOdchylkyDo: NullableInt32 read FIDOdchylkyDo write FIDOdchylkyDo;

    [MVCColumn('Sklad')]
    [MVCSwagJsonSchemaField(stString, 'Sklad', 'Číslo skladu', false, true, 1, 30)]
    property Sklad: string read FSklad write FSklad;

    [MVCColumn('Barcode')]
    [MVCSwagJsonSchemaField(stString, 'Barcode', 'Barcode operace', true, false, 1, 30)]
    property Barcode: string read FBarcode write FBarcode;

    [MVCColumn('VychoziSklad')]
    [MVCSwagJsonSchemaField(stString, 'VychoziSklad', 'Výchozí sklad pro výdej do výroby', false, true, 1, 30)]
    property VychoziSklad: string read FVychoziSklad write FVychoziSklad;

    [MVCColumn('RezijniMat')]
    [MVCSwagJsonSchemaField(stBoolean, 'RezijniMat', 'Režijní materiál', false, false)]
    property RezijniMat: boolean read FRezijniMat write FRezijniMat default false;

    [MVCColumn('Prednastaveno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Prednastaveno', 'Přednastaveno', false, false)]
    property Prednastaveno: boolean read FPrednastaveno write FPrednastaveno default true;

    [MVCColumn('Predzpracovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Predzpracovano', 'Předzpracováno', false, false)]
    property Predzpracovano: boolean read FPredzpracovano write FPredzpracovano default false;

    [MVCColumn('IDPracoviste')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPracoviste', 'ID pracoviště', false, true)]
    property IDPracoviste: NullableInt32 read FIDPracoviste write FIDPracoviste;

    [MVCColumn('Vyssi')]
    [MVCSwagJsonSchemaField(stInteger, 'Vyssi', 'ID kmene vyšší', true, false)]
    property Vyssi: integer read FVyssi write FVyssi;

    [MVCColumn('SZVyssi')]
    [MVCSwagJsonSchemaField(stString, 'SZVyssi', 'Skupina karet vyšší karty', true, false, 3, 3)]
    property SZVyssi: string read FSZVyssi write FSZVyssi;

    [MVCColumn('RCVyssi')]
    [MVCSwagJsonSchemaField(stString, 'RCVyssi', 'Reg.číslo vyšší karty', true, false, 1, 30)]
    property RegCisVyssi: string read FRegCisVyssi write FRegCisVyssi;

    [MVCColumn('Nizsi')]
    [MVCSwagJsonSchemaField(stInteger, 'Nizsi', 'ID kmene nižší', true, false)]
    property Nizsi: integer read FNizsi write FNizsi;

    [MVCColumn('SZNizsi')]
    [MVCSwagJsonSchemaField(stString, 'SZNizsi', 'Skupina karet nižší karty', true, false, 3, 3)]
    property SZNizsi: string read FSZNizsi write FSZNizsi;

    [MVCColumn('RCNizsi')]
    [MVCSwagJsonSchemaField(stString, 'RCNizsi', 'Reg.číslo nižší karty', true, false, 1, 30)]
    property RegCisNizsi: string read FRegCisNizsi write FRegCisNizsi;

    [MVCColumn('Nazev1Nizsi')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1Nizsi', 'Název 1 nižší karty', true, false, 1, 100)]
    property Nazev1Nizsi: string read FNazev1Nizsi write FNazev1Nizsi;

    [MVCColumn('Pozice')]
    [MVCSwagJsonSchemaField(stString, 'Pozice', 'Pozice', false, true, 1, 100)]
    property Pozice: string read FPozice write FPozice;

    [MVCColumn('Operace')]
    [MVCSwagJsonSchemaField(stString, 'Operace', 'Operace', false, true, 1, 4)]
    property Operace: string read FOperace write FOperace;

    [MVCColumn('SpotRozmer')]
    [MVCSwagJsonSchemaField(stString, 'SpotRozmer', 'Spotřební rozměr', false, true, 1, 100)]
    property SpotRozmer: string read FSpotRozmer write FSpotRozmer;

    [MVCColumn('FixniMnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'FixniMnozstvi', 'Fixní množství', false, false)]
    property FixniMnozstvi: Extended read FFixniMnozstvi write FFixniMnozstvi;

    [MVCColumn('Mnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnozstvi', 'Množství', true, false)]
    property Mnozstvi: Extended read FMnozstvi write FMnozstvi;

    [MVCColumn('ProcZtrat')]
    [MVCSwagJsonSchemaField(stNumber, 'ProcZtrat', 'Procento ztrát', true, false)]
    property ProcentoZtrat: Extended read FProcZtrat write FProcZtrat;

    [MVCColumn('MnozstviSeZtratou')]
    [MVCSwagJsonSchemaField(stNumber, 'MnozstviSeZtratou', 'Množství se ztrátou', false, false)]
    property MnozstviSeZtratou: Extended read FmnozstviSeZtratou write FmnozstviSeZtratou;

    [MVCColumn('Mnoz_zad')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnoz_zad', 'Množství zadané', false, false)]
    property MnozstviZadane: Extended read FMnozstviZadane write FMnozstviZadane;

    [MVCColumn('Prirez')]
    [MVCSwagJsonSchemaField(stNumber, 'Prirez', 'Počet kusů z přířezu', false, false)]
    property Prirez: Extended read FPrirez write FPrirez;

    [MVCColumn('Mnoz_nepotrebne')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnoz_nepotrebne', 'Množství nepotřebné', false, false)]
    property Mnoz_nepotrebne: Extended read FMnoz_nepotrebne write FMnoz_nepotrebne;

    [MVCColumn('Mnoz_skut_realizovane')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnoz_skut_realizovane', 'Množství vydané', true, false)]
    property MnozstviSkutecneRealizovane: Extended read FMnoz_skut_realizovane write FMnoz_skut_realizovane;
{
    [MVCColumn('Mnoz_skut_realizovane')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnoz_skut_realizovane', 'Množství nepotřebné', false, false)]
    property MnozstviOdvedene: Single index clMnozstviOdvedene read FMnoz_odv write FMnoz_odv; // write WritePropReadOnlySingle;
}
    [MVCColumn('mnoz_Nevydane')]
    [MVCSwagJsonSchemaField(stNumber, 'mnoz_Nevydane', 'Množství nevydané', false, true)]
    property MnozstviNevydane: Extended index clMnozNevydane read FMnozstviNevydane write FMnozstviNevydane; // read ReadPropSingle write WritePropReadOnlySingle;

    [MVCColumn('RefMnoz')]
    [MVCSwagJsonSchemaField(stNumber, 'RefMnoz', 'Referenční množství', false, false)] // Pro vnitřní účely, realizované + nepotřebné
    property RefMnoz: Extended read FRefMnoz write FRefMnoz;

    [MVCColumn('VydanoRefMnoz')]
    [MVCSwagJsonSchemaField(stNumber, 'VydanoRefMnoz', 'Vydáno ref. množství', false, false)] // Pro vnitřní účely, realizované + nepotřebné
    property VydanoRefMnoz: Extended read FVydanoRefMnoz write FVydanoRefMnoz;

{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCColumn('TypDilce')]
    [MVCSwagJsonSchemaField(stString, 'TypDilce', 'Typ dílce', false, true)]
    property TypDilce: NullableString read FTypDilce write FTypDilce;
{$ENDIF}
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabCKoop')]
  TTPVCisKoop = class(THeliosObjekty)
    FBlokovano: boolean;
    FRada: string;
    FKod: string;
    FNazev: NullableString;
    FDodavatel: NullableInt32;
    FMistoUrceni: NullableInt32;
   public
    [MVCColumn('Blokovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Blokovano', 'Archivní záznam', true, false)]
    property Blokovano: boolean read FBlokovano write FBlokovano;

    [MVCColumn('Rada')]
    [MVCSwagJsonSchemaField(stString, 'Rada', 'Řada kooperace', true, false)]
    property Rada: string read FRada write FRada;

    [MVCColumn('Kod')]
    [MVCSwagJsonSchemaField(stString, 'Kod', 'Kód kooperace', true, false, 1, 10)]
    property Kod: string read FKod write FKod;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název kooperace', false, true, 1, 100)]
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('Dodavatel')]
    [MVCSwagJsonSchemaField(stInteger, 'Dodavatel', 'Číslo organizace dodavatele', false, true)]
    property Dodavatel: NullableInt32 read FDodavatel write FDodavatel;

    [MVCColumn('MistoUrceni')]
    [MVCSwagJsonSchemaField(stInteger, 'MistoUrceni', 'Místo určení', false, true)]
    property MistoUrceni: NullableInt32 read FMistoUrceni write FMistoUrceni;
  end;






  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPostup')]
  TTPVOperaceDilce = class(THeliosObjekty)
   private
    FDilec: integer;
    FIDZakazModif: NullableInt32;
    FIDVarianta: NullableInt32;
    FOdvadeci: boolean;
    FTyp: integer;
    FZmenaOd: NullableInt32;
    FZmenaDo: NullableInt32;
   public
    constructor Create; // nastaveni Default hodnot

    [MVCColumn('dilec')]
    [MVCSwagJsonSchemaField(stInteger, 'dilec', 'ID kmenové karty', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property dilec: integer read FDilec write FDilec;

    [MVCColumn('IDZakazModif')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZakazModif', 'Interní ID zakázkové modifikace', false, true)]
    property IDZakazModif: NullableInt32 read FIDZakazModif write FIDZakazModif;

    [MVCColumn('IDVarianta')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVarianta', 'Interní ID varianty', false, true)]
    property IDVarianta: NullableInt32 read FIDVarianta write FIDVarianta;

    [MVCColumn('Odvadeci')]
    [MVCSwagJsonSchemaField(stBoolean, 'Odvadeci', 'Odváděcí operace', true, false)]
    property Odvadeci: Boolean read FOdvadeci write FOdvadeci;

    [MVCColumn('Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'Typ', 'Typ operace (0=Režijní operace/1=Jednicová operace/2=Kooperace)', true, false)]
    property Typ: integer read FTyp write FTyp;

    [MVCColumn('ZmenaOd')]
    [MVCSwagJsonSchemaField(stInteger, 'ZmenaOd', 'ID čísleníku změn', true, false)]
    property ZmenaOd: NullableInt32 read FZmenaOd write FZmenaOd;

    [MVCColumn('ZmenaDo')]
    [MVCSwagJsonSchemaField(stInteger, 'ZmenaDo', 'ID čísleníku změn', true, false)]
    property ZmenaDo: NullableInt32 read FZmenaDo write FZmenaDo;

  end;



  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPrikazMzdyAZmetky')]
  TVyrobaEvidovanaOperace = class(THeliosObjekty)
   private
//    [MVCTableField('ID',[foPrimaryKey])]
//    FID: integer;
    FDatum: TDateTime;
    FIDSmeny: NullableInt32;
    FStav: Integer;
    FIDKoopObj: NullableInt32;
    FIDPolKoopObj: NullableInt32;
    FIDPrikaz: NullableInt32;
    FDokladPrPostup: NullableInt32;
    FAltPrPostup: NullableString;
    FNazevOperace: NullableString;

    FIDTabKmen: NullableInt32;
    FIDTabStrom: NullableString;
    FIDPracoviste: NullableInt32;
    FIDStroje: NullableInt32;
    FIDVyrCis: NullableInt32;
    FDatumZahajeniOp: NullableTDateTime;
    FDatumUkonceniOp: NullableTDateTime;
    FZamestnanec: NullableInt32;
    FTarif: NullableInt32;

    FKusyOdv: Extended;
    FKusyZmetOprav: Extended;
    FKusyZmetIntOprav: Extended;
    FKusyZmetNeoprav: Extended;
    FOperOdv: Extended;
    FOperZmetOprav: Extended;
    FOperZmetIntOprav: Extended;
    FOperZmetNeoprav: Extended;

    FNorCas: Extended;
    FNorCasT: integer;
    FNorCasObsl: Extended;
    FNorCasObslT: integer;
    FSkCas: Extended;
    FSkCasT: integer;
    FSkCasObsl: Extended;
    FSkCasObslT: integer;

    FMena: NullableString;
    FKurz: Extended;
    FNormoMzda: Extended;
    FNormoMzdaVal: Extended;
    FMzda: Extended;
    FMzdaVal: Extended;

    FIDSdruzVyrOperaceR: NullableInt32;
    FIDEvidRozpracOperR: NullableInt32;
    FIDEvidRozpracOper: NullableInt32;
   public
{
    [MVCTableField('ID', [foPrimaryKey, foReadOnly])]
    [MVCColumn('ID')]
    [MVCSwagJsonSchemaField(stInteger, 'ID', 'ID výrobní operace', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property ID: integer read FID write FID;
}
    [MVCColumn('Datum')]
    [MVCSwagJsonSchemaField(stDateTime, 'Datum', 'Datum', true, false)]
    property Datum: TDateTime read FDatum write FDatum;

    [MVCColumn('IDSmeny')]
    [MVCSwagJsonSchemaField(stInteger, 'IDSmeny', 'ID smeny', false, true)]
    property IDSmeny: NullableInt32 read FIDSmeny write FIDSmeny;

    [MVCColumn('Stav')]
    [MVCSwagJsonSchemaField(stInteger, 'Stav', 'Stav - 0=porizeno, 1=realizovano', true, false)]
    property Stav: integer read FStav write FStav;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID prikazu', false, true)]
    property IDPrikaz: NullableInt32 read FIDPrikaz write FIDPrikaz;

    [MVCColumn('DokladPrPostup')]
    [MVCSwagJsonSchemaField(stInteger, 'DokladPrPostup', 'Doklad pracovniho postupu', false, true)]
    property DokladPrPostup: NullableInt32 read FDokladPrPostup write FDokladPrPostup;

    [MVCColumn('AltPrPostup')]
    [MVCSwagJsonSchemaField(stString, 'AltPrPostup', 'Alernativa pracovniho postupu', false, true)]
    property AltPrPostup: NullableString read FAltPrPostup write FAltPrPostup;

    [MVCColumn('NazevOperace')]
    [MVCSwagJsonSchemaField(stString, 'NazevOperace', 'Nazev pracovniho postupu', false, true)]
    property NazevOperace: NullableString read FNazevOperace write FNazevOperace;

    [MVCColumn('IDTabKmen')]
    [MVCSwagJsonSchemaField(stInteger, 'IDTabKmen', 'ID kmenové karty dílce', false, true)]
    property IDTabKmen: NullableInt32 read FIDTabKmen write FIDTabKmen;

    [MVCColumn('IdTabStrom')]
    [MVCSwagJsonSchemaField(stString, 'IdTabStrom', 'Sklad', false, true)]
    property IdTabStrom: NullableString read FIdTabStrom write FIdTabStrom;

    [MVCColumn('IDPracoviste')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPracoviste', 'ID pracoviste', false, true)]
    property IDPracoviste: NullableInt32 read FIDPracoviste write FIDPracoviste;

    [MVCColumn('IDStroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStroje', 'ID stroje', false, true)]
    property IDStroje: NullableInt32 read FIDStroje write FIDStroje;

    [MVCColumn('Zamestnanec')]
    [MVCSwagJsonSchemaField(stInteger, 'Zamestnanec', 'ID zamestnance', false, true)]
    property Zamestnanec: NullableInt32 read FZamestnanec write FZamestnanec;

    [MVCColumn('IDVyrCis')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVyrCis', 'ID vyrobniho cisla prikazu', false, true)]
    property IDVyrCis: NullableInt32 read FIDVyrCis write FIDVyrCis;

    [MVCColumn('DatumZahajeniOp')]
    [MVCSwagJsonSchemaField(stInteger, 'DatumZahajeniOp', 'Datum a cas zahajeni operace (z evidence rozprac.operaci)', false, true)]
    property DatumZahajeniOp: NullableTDateTime read FDatumZahajeniOp write FDatumZahajeniOp;

    [MVCColumn('DatumUkonceniOp')]
    [MVCSwagJsonSchemaField(stInteger, 'DatumUkonceniOp', 'Datum a cas ukonceni operace (z evidence rozprac.operaci)', false, true)]
    property DatumUkonceniOp: NullableTDateTime read FDatumUkonceniOp write FDatumUkonceniOp;

    [MVCColumn('kusy_odv')]
    [MVCSwagJsonSchemaField(stNumber, 'kusy_odv', 'Pocet odvedenych ks', true, false)]
    property kusy_odv: Extended read FKusyOdv write FKusyOdv;

    [MVCColumn('kusy_zmet_opr')]
    [MVCSwagJsonSchemaField(stNumber, 'kusy_zmet_opr', 'Pocet opravitelnych zmetku', true, false)]
    property kusy_zmet_opr: Extended read FKusyZmetOprav write FKusyZmetOprav;

    [MVCColumn('kusy_zmet_opr_IO')]
    [MVCSwagJsonSchemaField(stNumber, 'kusy_zmet_opr_IO', 'Pocet interne opravitelnych zmetku', true, false)]
    property kusy_zmet_opr_IO: Extended read FKusyZmetIntOprav write FKusyZmetIntOprav;

    [MVCColumn('kusy_zmet_neopr')]
    [MVCSwagJsonSchemaField(stNumber, 'kusy_zmet_neopr', 'Pocet neopravitelnych zmetku', true, false)]
    property kusy_zmet_neopr: Extended read FKusyZmetNeoprav write FKusyZmetNeoprav;

    [MVCColumn('Operace_odv')]
    [MVCSwagJsonSchemaField(stNumber, 'Operace_odv', 'Pocet odvedenych operaci', true, false)]
    property Operace_odv: Extended read FOperOdv write FOperOdv;

    [MVCColumn('Operace_zmet_opr')]
    [MVCSwagJsonSchemaField(stNumber, 'Operace_zmet_opr', 'Pocet opravitelnych operaci', true, false)]
    property Operace_zmet_opr: Extended read FOperZmetOprav write FOperZmetOprav;

    [MVCColumn('Operace_zmet_opr_IO')]
    [MVCSwagJsonSchemaField(stNumber, 'Operace_zmet_opr_IO', 'Pocet interne opravitelnych operaci', true, false)]
    property Operace_zmet_opr_IO: Extended read FOperZmetIntOprav write FOperZmetIntOprav;

    [MVCColumn('Operace_zmet_neopr')]
    [MVCSwagJsonSchemaField(stNumber, 'Operace_zmet_neopr', 'Pocet neopravitelnych operaci', true, false)]
    property Operace_zmet_neopr: Extended read FOperZmetNeoprav write FOperZmetNeoprav;

    [MVCColumn('Tarif')]
    [MVCSwagJsonSchemaField(stInteger, 'Tarif', 'ID tarifu operace', false, true)]
    property Tarif: NullableInt32 read FTarif write FTarif;

    [MVCColumn('Nor_cas')]
    [MVCSwagJsonSchemaField(stNumber, 'Nor_cas', 'Normovany cas (typ viz Nor_cas_T)', true, false)]
    property Nor_cas: Extended read FNorCas write FNorCas;

    [MVCColumn('Nor_cas_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Nor_cas_T', 'Typ normovaneho casu (0=sec / 1=min / 2=hod)', true, false)]
    property Nor_cas_T: integer read FNorCasT write FNorCasT default 1;

    [MVCColumn('Nor_cas_Obsluhy')]
    [MVCSwagJsonSchemaField(stNumber, 'Nor_cas_Obsluhy', 'Normovany cas obsluhy (typ viz Nor_cas_Obsluhy_T)', true, false)]
    property Nor_cas_Obsluhy: Extended read FNorCasObsl write FNorCasObsl;

    [MVCColumn('Nor_cas_Obsluhy_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Nor_cas_Obsluhy_T', 'Typ normovaneho casu obsluhy (0=sec / 1=min / 2=hod)', true, false)]
    property Nor_cas_Obsluhy_T: integer read FNorCasObslT write FNorCasObslT default 1;

    [MVCColumn('Sk_cas')]
    [MVCSwagJsonSchemaField(stNumber, 'Sk_cas', 'Skutecny cas (typ viz Nor_cas_T)', true, false)]
    property Sk_cas: Extended read FSkCas write FSkCas;

    [MVCColumn('Sk_cas_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Sk_cas_T', 'Typ skutecneho casu (0=sec / 1=min / 2=hod)', true, false)]
    property Sk_cas_T: integer read FSkCasT write FSkCasT default 1;

    [MVCColumn('Sk_cas_Obsluhy')]
    [MVCSwagJsonSchemaField(stNumber, 'Sk_cas_Obsluhy', 'Skutecny cas obsluhy (typ viz Nor_cas_Obsluhy_T)', true, false)]
    property Sk_cas_Obsluhy: Extended read FSkCasObsl write FSkCasObsl;

    [MVCColumn('Sk_cas_Obsluhy_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Sk_cas_Obsluhy_T', 'Typ skutecneho casu obsluhy (0=sec / 1=min / 2=hod)', true, false)]
    property Sk_cas_Obsluhy_T: integer read FSkCasObslT write FSkCasObslT default 1;


    [MVCColumn('Mena')]
    [MVCSwagJsonSchemaField(stString, 'Mena', 'Mena', false, true)]
    property Mena: NullableString read FMena write FMena;

    [MVCColumn('Kurz')]
    [MVCSwagJsonSchemaField(stNumber, 'Kurz', 'Kurz', true, false)]
    property Kurz: Extended read FKurz write FKurz;

    [MVCColumn('NormoMzda')]
    [MVCSwagJsonSchemaField(stNumber, 'NormoMzda', 'Mzda za normu', true, false)]
    property NormoMzda: Extended read FNormoMzda write FNormoMzda;

    [MVCColumn('NormoMzdaVal')]
    [MVCSwagJsonSchemaField(stNumber, 'NormoMzdaVal', 'Mzda za normu (valuty)', true, false)]
    property NormoMzdaVal: Extended read FNormoMzdaVal write FNormoMzdaVal;

    [MVCColumn('Mzda')]
    [MVCSwagJsonSchemaField(stNumber, 'Mzda', 'Mzda za skutecne odpracovany cas', true, false)]
    property Mzda: Extended read FMzda write FMzda;

    [MVCColumn('MzdaVal')]
    [MVCSwagJsonSchemaField(stNumber, 'MzdaVal', 'Mzda (valuty) za skutecne odpracovany cas', true, false)]
    property MzdaVal: Extended read FMzdaVal write FMzdaVal;


    [MVCColumn('IDEvidRozpracOperR')]
    [MVCSwagJsonSchemaField(stInteger, 'IDEvidRozpracOperR', 'ID radku evidence rozpracovanych operaci', false, true)]
    property IDEvidRozpracOperR: NullableInt32 read FIDEvidRozpracOperR write FIDEvidRozpracOperR;

    [MVCColumn('IDEvidRozpracOper')]
    [MVCSwagJsonSchemaField(stInteger, 'IDEvidRozpracOper', 'ID evidence rozpracovanych operaci', false, true)]
    property IDEvidRozpracOper: NullableInt32 read FIDEvidRozpracOper write FIDEvidRozpracOper;
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPrPostup')]
  TVyrobniOperace = class(THeliosObjekty)
   private
//    [MVCTableField('ID',[foPrimaryKey])]
//    FID: integer;
    [MVCTableField('Uzavreno')]
    FUzavreno: boolean;
    [MVCTableField('Prednastaveno')]
    FPrednastaveno: boolean;
    [MVCTableField('Predzpracovano')]
    FPredzpracovano: boolean;
    [MVCTableField('Odvadeci')]
    FOdvadeci: boolean;
    [MVCTableField('Barcode')]
    FBarcode: string;

    [MVCTableField('Priorita')]
    FPriorita: integer;
    [MVCTableField('Doklad')]
    FDoklad: integer;
    [MVCTableField('Alt')]
    FAlt: Char;
    [MVCTableField('IDPrikaz')]
    FIDPrikaz: integer;
    [MVCTableField('Operace')]
    FOperace: string;
    [MVCTableField('Nazev')]
    FNazev: string;
    [MVCTableField('Poznamka')]
    FPoznamka: string;
    [MVCTableField('PocetKP')]
    FPocetKP: integer;

    [MVCTableField('Kusy_zad')]
    FKusy_zad: Extended;
    [MVCTableField('Kusy_nepotrebne')]
    FKusy_nepotrebne: Extended;
    [MVCTableField('Kusy_ciste')]
    FKusy_ciste: Extended;
    [MVCTableField('Kusy_zive')]
    FKusy_zive: Extended;
    [MVCTableField('Kusy_predOper')]
    FKusy_predOper: Extended;
    [MVCTableField('Kusy_vKoop')]
    FKusy_vKoop: Extended;
    [MVCTableField('Kusy_real')]
    FKusy_real: Extended;
    [MVCTableField('Kusy_odv')]
    FKusy_odv: Extended;
    [MVCTableField('Kusy_predOperaci')]
    FKusy_predOperaci: Extended;
    [MVCTableField('Kusy_zmet')]
    FKusy_zmet: Extended;
    [MVCTableField('Kusy_zmet_oprIO')]
    FKusy_zmet_oprIO: Extended;
    [MVCTableField('Kusy_zmet_neopr')]
    FKusy_zmet_neopr: Extended;
    [MVCTableField('Kusy_ztrac')]
    FKusy_ztrac: Extended;

    [MVCTableField('infoKusy_zad')]
    FinfoKusy_zad: Extended;
    [MVCTableField('infoKusy_odv')]
    FinfoKusy_odv: Extended;
    [MVCTableField('infoKusy_zive')]
    FinfoKusy_zive: Extended;
    [MVCTableField('infoKusy_zmet')]
    FinfoKusy_zmet: Extended;
    [MVCTableField('infoKusy_zmet_neopr')]
    FinfoKusy_zmet_neopr: Extended;

    [MVCTableField('Dilec')]
    FDilec: integer;
    [MVCTableField('Typ')]
    FTyp: integer;
    [MVCTableField('DavkaTPV')]
    FDavkaTPV: Extended;
    [MVCTableField('NasobekTAC')]
    FNasobekTAC: Extended;
    [MVCTableField('IDStroje')]
    FIDStroje: NullableInt32;
    FStrojNazev: NullableString;
    FStrojKod: NullableString;
    [MVCTableField('IDKooperace')]
    FIDKooperace: integer;
    [MVCTableField('Pracoviste')]
    FPracoviste: integer;
    [MVCTableField('PocetLidi')]
    FPocetLidi: integer;
    [MVCTableField('PocetKusu')]
    FPocetKusu: Extended;
    [MVCTableField('PocetStroju')]
    FPocetStroju: integer;

    [MVCTableField('MeziOperCas')]
    FMeziOperCas: Extended;
    [MVCTableField('MeziOperCas_Typ')]
    FMeziOperCas_Typ: integer;

    [MVCTableField('CasZbyvajiciHod')]
    FCasZbyvajiciHod: NullableSingle;

    [MVCTableField('TBC')]
    FTBC: Extended;
    [MVCTableField('TBC_Typ')]
    FTBC_Typ: integer;
    [MVCTableField('TBC_Obsl')]
    FTBC_Obsl: Extended;
    [MVCTableField('TBC_Obsl_Typ')]
    FTBC_Obsl_Typ: integer;
    [MVCTableField('TBC_KC')]
    FTBC_KC: Extended;

    [MVCTableField('TAC')]
    FTAC: Extended;
    [MVCTableField('TAC_Typ')]
    FTAC_Typ: integer;
    [MVCTableField('TAC_Obsl')]
    FTAC_Obsl: Extended;
    [MVCTableField('TAC_Obsl_Typ')]
    FTAC_Obsl_Typ: integer;
    [MVCTableField('TAC_KC')]
    FTAC_KC: Extended;
    [MVCTableField('TAC_J')]
    FTAC_J: Extended;
    [MVCTableField('TAC_J_Typ')]
    FTAC_J_Typ: integer;
    [MVCTableField('TAC_J_Obsl')]
    FTAC_J_Obsl: Extended;
    [MVCTableField('TAC_J_Obsl_Typ')]
    FTAC_J_Obsl_Typ: integer;
    [MVCTableField('TAC_J_KC')]
    FTAC_J_KC: Extended;

    [MVCTableField('TEC')]
    FTEC: Extended;
    [MVCTableField('TEC_Typ')]
    FTEC_Typ: integer;
    [MVCTableField('TEC_Obsl')]
    FTEC_Obsl: Extended;
    [MVCTableField('TEC_Obsl_Typ')]
    FTEC_Obsl_Typ: integer;
    [MVCTableField('TEC_KC')]
    FTEC_KC: Extended;

    [MVCTableField('PlanZadani')]
    FPlanZadani: NullableTDateTime;
    [MVCTableField('PlanUkonceni')]
    FPlanUkonceni: NullableTDateTime;

{
    procedure NastavString(const Index: integer; const Value: string);
    procedure NastavInt(const Index: integer; const Value: integer);
    procedure NastavSingle(const Index: integer; const Value: Single);
    procedure NastavByte(const Index: integer; const Value: byte);
}

   protected
    procedure OnAfterLoad; override;
    procedure OnAfterInsert; override;

   public
{
    [MVCTableField('ID', [foPrimaryKey, foReadOnly])]
    [MVCColumn('ID')]
    [MVCSwagJsonSchemaField(stInteger, 'ID', 'ID výrobní operace', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property ID: integer read FID write FID;
}

    [MVCColumn('Priorita')]
    [MVCSwagJsonSchemaField(stInteger, 'Priorita', 'Priorita', true, false)]
    property Priorita: integer read FPriorita write FPriorita;

    [MVCColumn('Uzavreno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Uzavreno', 'Uzavřená operace', true, false)]
    property Uzavreno: Boolean read FUzavreno write FUzavreno;

    [MVCColumn('Prednastaveno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Prednastaveno', 'Přednastaveno', true, false)]
    property Prednastaveno: Boolean read FPrednastaveno write FPrednastaveno;

    [MVCColumn('Predzpracovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Predzpracovano', 'Předzpracováno', true, false)]
    property Predzpracovano: Boolean read FPredzpracovano write FPredzpracovano;

    [MVCColumn('Odvadeci')]
    [MVCSwagJsonSchemaField(stBoolean, 'Odvadeci', 'Odváděcí operace', true, false)]
    property Odvadeci: Boolean read FOdvadeci write FOdvadeci;



    [MVCColumn('Doklad')]
    [MVCSwagJsonSchemaField(stInteger, 'Doklad', 'Doklad', true, false)]
    property Doklad: integer read FDoklad write FDoklad;

    [MVCColumn('Alt')]
    [MVCSwagJsonSchemaField(stChar, 'Alt', 'Alternativní operace', true, false, 1, 1)]
    property Alt: Char read FAlt write FAlt;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID vyrobniho prikazu', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('Operace')]
    [MVCSwagJsonSchemaField(stString, 'Operace', 'Číslo operace', true, false, 0, 4)]
    property Operace: string read FOperace write FOperace;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název operace', true, false, 0, 100)]
    property Nazev: string read FNazev write FNazev;

    [MVCColumn('Barcode')]
    [MVCSwagJsonSchemaField(stString, 'Barcode', 'Ćárový kód operace', true, false, 0, 15)]
    property Barcode: string read FBarcode write FBarcode;

    [MVCColumn('PocetKP')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetKP', 'Počet kontrolních postupů', true, false)]
    property PocetKP: integer read FPocetKP write FPocetKP;


    [MVCColumn('Kusy_zad')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zad', 'Kusy zadané', true, false)]
    property KusyZadane: Extended read FKusy_zad write FKusy_zad;

    [MVCColumn('info_KusyZadane')]
    [MVCSwagJsonSchemaField(stNumber, 'info_KusyZadane', '(info) Kusy zadané', true, false)]
    property info_KusyZadane: Extended read FinfoKusy_zad write FinfoKusy_zad;

    [MVCColumn('Kusy_nepotrebne')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_nepotrebne', 'Kusy nepotřebné', true, false)]
    property Kusy_nepotrebne: Extended read FKusy_nepotrebne write FKusy_nepotrebne;

    [MVCColumn('Kusy_ciste')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_ciste', 'Kusy čisté', true, false)]
    property KusyCiste: Extended read FKusy_ciste write FKusy_ciste;

    [MVCColumn('Kusy_zive')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zive', 'Kusy živé', true, false)]
    property KusyZive: Extended read FKusy_zive write FKusy_zive;

    [MVCColumn('Kusy_zive')]
    [MVCSwagJsonSchemaField(stNumber, 'info_KusyZive', '(info) Kusy živé', true, false)]
    property info_KusyZive: Extended read FinfoKusy_zive write FinfoKusy_zive;

    [MVCColumn('Kusy_predOper')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_predOper', 'Kusy před oeprací', true, false)]
    property Kusy_predOper: Extended read FKusy_predOper write FKusy_predOper;

    [MVCColumn('Kusy_vKoop')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_vKoop', 'Kusy v kooperaci', true, false)]
    property Kusy_vKoop: Extended read FKusy_vKoop write FKusy_vKoop;

    [MVCColumn('Kusy_real')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_real', 'Kusy realizované', true, false)]
    property Kusy_real: Extended read FKusy_real write FKusy_real;

    [MVCColumn('Kusy_odv')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_odv', 'Kusy odvedené', true, false)]
    property Kusy_odv: Extended read FKusy_odv write FKusy_odv;

    [MVCColumn('_info_Kusy_odv')]
    [MVCSwagJsonSchemaField(stNumber, '_info_Kusy_odv', '(info) Kusy odvedené', true, false)]
    property info_Kusy_odv: Extended read FinfoKusy_odv write FinfoKusy_odv;

    [MVCColumn('KusyPredOperaci')]
    [MVCSwagJsonSchemaField(stNumber, 'KusyPredOperaci', 'Kusy před operací', true, false)]
    property KusyPredOperaci: Extended read FKusy_predOper write FKusy_predOper;

    [MVCColumn('Kusy_zmet')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zmet', 'Zmetky opravitelné', true, false)]
    property Kusy_zmet: Extended read FKusy_zmet write FKusy_zmet;

    [MVCColumn('Kusy_zmet')]
    [MVCSwagJsonSchemaField(stNumber, 'info_Kusy_zmet', '(info) Zmetky opravitelné', true, false)]
    property info_Kusy_zmet: Extended read FinfoKusy_zmet write FinfoKusy_zmet;

    [MVCColumn('Kusy_zmet_oprIO')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zmet_oprIO', 'Zmetky IO (interně opravitelné)', true, false)]
    property Kusy_zmet_oprIO: Extended read FKusy_zmet_oprIO write FKusy_zmet_oprIO;

    [MVCColumn('Kusy_zmet_neopr')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zmet_neopr', 'Zmetky neopravitelné', true, false)]
    property Kusy_zmet_neopr: Extended read FKusy_zmet_neopr write FKusy_zmet_neopr;

    [MVCColumn('_info_Kusy_zmet_neopr')]
    [MVCSwagJsonSchemaField(stNumber, '_info_Kusy_zmet_neopr', '(info) Zmetky neopravitelné', true, false)]
    property info_Kusy_zmet_neopr: Extended read FinfoKusy_zmet_neopr write FinfoKusy_zmet_neopr;

    [MVCColumn('Kusy_ztrac')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_ztrac', 'Ztracené kusy', true, false)]
    property Kusy_ztrac: Extended read FKusy_ztrac write FKusy_ztrac;



    [MVCColumn('Dilec')]
    [MVCSwagJsonSchemaField(stInteger, 'Dilec', 'ID dílce', true, false)]
    property Dilec: integer read FDilec write FDilec;

    [MVCColumn('Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'Typ', 'Typ operace (0=Režijní operace/1=Jednicová operace/2=Kooperace)', true, false)]
    property Typ: integer read FTyp write FTyp;

    [MVCColumn('DavkaTPV')]
    [MVCSwagJsonSchemaField(stNumber, 'DavkaTPV', 'Dávka TPV', true, false)]
    property DavkaTPV: Extended read FDavkaTPV write FDavkaTPV;

    [MVCColumn('NasobekTAC')]
    [MVCSwagJsonSchemaField(stNumber, 'NasobekTAC', 'Násobek TAC', true, false)]
    property NasobekTAC: Extended read FNasobekTAC write FNasobekTAC;

    [MVCColumn('IDStroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStroje', 'ID stroje', true, false)]
    property IDStroje: NullableInt32 read FIDStroje write FIDStroje;

    [MVCColumn('StrojNazev')]
    [MVCSwagJsonSchemaField(stString, 'StrojNazev', 'Název stroje', false, true, 0, 40)]
    property StrojNazev: NullableString read FStrojNazev write FStrojNazev;

    [MVCColumn('StrojKod')]
    [MVCSwagJsonSchemaField(stString, 'StrojKod', 'Kód stroje', false, true, 0, 40)]
    property StrojKod: NullableString read FStrojKod write FStrojKod;

    [MVCColumn('IDKooperace')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKooperace', 'ID kooperace', true, false)]
    property IDKooperace: integer read FIDKooperace write FIDKooperace;

    [MVCColumn('pracoviste')]
    [MVCSwagJsonSchemaField(stInteger, 'pracoviste', 'ID pracoviště', true, false)]
    property IDPracoviste: integer read FPracoviste write FPracoviste;

    [MVCColumn('PocetLidi')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetLidi', 'Počet lidí', true, false)]
    property PocetLidi: integer read FPocetLidi write FPocetLidi;

    [MVCColumn('PocetKusu')]
    [MVCSwagJsonSchemaField(stNumber, 'PocetKusu', 'Počet kusů', true, false)]
    property PocetKusu: Extended read FPocetKusu write FPocetKusu;

    [MVCColumn('PocetStroju')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetStroju', 'Počet strojů', true, false)]
    property PocetStroju: integer read FPocetStroju write FPocetStroju;



    [MVCColumn('MeziOperCas')]
    [MVCSwagJsonSchemaField(stNumber, 'MeziOperCas', 'Mezioperační čas', true, false)]
    property MeziOperCas: Extended read FMeziOperCas write FMeziOperCas;

    [MVCColumn('MeziOperCas_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'MeziOperCas_Typ', 'Typ mezioperačního času', true, false)]
    property MeziOperCas_Typ: integer read FMeziOperCas_Typ write FMeziOperCas_Typ;


    [MVCColumn('ZbyvajiciCas_H')]
    [MVCSwagJsonSchemaField(stNumber, 'ZbyvajiciCas_H', 'Zbývající čas stroje [hod]', true, true)]
    property ZbyvajiciCas_H: NullableSingle read FCasZbyvajiciHod write FCasZbyvajiciHod;



    [MVCColumn('TBC')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC', 'Přípravný čas strojní', true, false)]
    property TBC: Extended read FTBC write FTBC;

    [MVCColumn('TBC_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TBC_Typ', 'Typ strojního přípravného času', true, false)]
    property TBC_Typ: integer read FTBC_Typ write FTBC_Typ;

    [MVCColumn('TBC_Obsl')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_Obsl', 'Přípravný čas obsluhy', true, false)]
    property TBC_Obsl: Extended read FTBC_Obsl write FTBC_Obsl;

    [MVCColumn('TBC_Obsl_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TBC_Obsl_Typ', 'Typ přípravného času obsluhy', true, false)]
    property TBC_Obsl_Typ: integer read FTBC_Obsl_Typ write FTBC_Obsl_Typ;

    [MVCColumn('TBC_KC')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_KC', 'Přípravná mzda obsluhy', true, false)]
    property TBC_KC: Extended read FTBC_KC write FTBC_KC;

    [MVCColumn('TAC')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC', 'Celkový jednicový čas', true, false)]
    property TAC: Extended read FTAC write FTAC;

    [MVCColumn('TAC_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TAC_Typ', 'Typ celkového jednicového času', true, false)]
    property TAC_Typ: integer read FTAC_Typ write FTAC_Typ;

    [MVCColumn('TAC_Obsl')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_Obsl', 'Celkový jednicový čas obsluhy', true, false)]
    property TAC_Obsl: Extended read FTAC_Obsl write FTAC_Obsl;

    [MVCColumn('TAC_Obsl_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TAC_Obsl_Typ', 'Typ celkového jednicového času obsluhy', true, false)]
    property TAC_Obsl_Typ: integer read FTAC_Obsl_Typ write FTAC_Obsl_Typ;

    [MVCColumn('TAC_KC')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_KC', 'Celková jednicová mzda', true, false)]
    property TAC_KC: Extended read FTAC_KC write FTAC_KC;

    [MVCColumn('TAC_J')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J', 'Jednicový čas', true, false)]
    property TAC_J: Extended read FTAC_J write FTAC_J;

    [MVCColumn('TAC_J_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TAC_J_Typ', 'Typ jednicového času', true, false)]
    property TAC_J_Typ: integer read FTAC_J_Typ write FTAC_J_Typ;

    [MVCColumn('TAC_J_Obsl')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J_Obsl', 'Jednicový čas obsluhy', true, false)]
    property TAC_J_Obsl: Extended read FTAC_J_Obsl write FTAC_J_Obsl;

    [MVCColumn('TAC_J_Obsl_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TAC_J_Obsl_Typ', 'Typ jednicového času obsluhy', true, false)]
    property TAC_J_Obsl_Typ: integer read FTAC_J_Obsl_Typ write FTAC_J_Obsl_Typ;

    [MVCColumn('TAC_J_KC')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J_KC', 'Jednicová mzda', true, false)]
    property TAC_J_KC: Extended read FTAC_J_KC write FTAC_J_KC;

    [MVCColumn('TEC')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC', 'Ukončovací čas', true, false)]
    property TEC: Extended read FTEC write FTEC;

    [MVCColumn('TEC_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TEC_Typ', 'Typ strojního ukončovacího času', true, false)]
    property TEC_Typ: integer read FTEC_Typ write FTEC_Typ;

    [MVCColumn('TEC_Obsl')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_Obsl', 'Ukončovací čas obsluhy', true, false)]
    property TEC_Obsl: Extended read FTEC_Obsl write FTEC_Obsl;

    [MVCColumn('TEC_Obsl_Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'TEC_Obsl_Typ', 'Typ ukončovacího času obsluhy', true, false)]
    property TEC_Obsl_Typ: integer read FTEC_Obsl_Typ write FTEC_Obsl_Typ;

    [MVCColumn('TEC_KC')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_KC', 'Ukončovací mzda obsluhy', true, false)]
    property TEC_KC: Extended read FTEC_KC write FTEC_KC;

    [MVCColumn('Plan_zadani')]
    [MVCSwagJsonSchemaField(stDate, 'Plan_zadani', 'Plánované zahájení', false, true)]
    property Plan_zadani: NullableTDateTime read FPlanZadani write FPlanZadani;

    [MVCColumn('Plan_ukonceni')]
    [MVCSwagJsonSchemaField(stDate, 'Plan_ukonceni', 'Plánované ukončení', false, true)]
    property Plan_ukonceni: NullableTDateTime read FPlanUkonceni write FPlanUkonceni;

  end;







  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabZakazModif')]
  TTPVZakazkovaModifikace = class(THeliosObjekty)
   private
    FBlokovano: integer;
    FRada: string;
    FKod: string;
    FNazev: NullableString;
    FDatumTPV: NullableTDateTime;
    FPoznamka: NullableString;
    FSchvaleno: boolean;
    FDatumSchvaleni: NullableTDateTime;
   public
    [MVCColumn('Rada')]
    [MVCSwagJsonSchemaField(stString, 'Rada', 'Řada', true, false, 0, 10)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Rada: string read FRada write FRada;

    [MVCColumn('Kod')]
    [MVCSwagJsonSchemaField(stString, 'Kod', 'Kód', true, false, 0, 20)]
    property Kod: string read FKod write FKod;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název', false, true, 1, 100)]
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('DatumTPV')]
    [MVCSwagJsonSchemaField(stDate, 'DatumTPV', 'Datum TPV', false, true)]
    property DatumTPV: NullableTDateTime read FDatumTPV write FDatumTPV;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('Schvaleno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Schvaleno', 'Schváleno', true, false)]
    property Schvaleno: boolean read FSchvaleno write FSchvaleno default false;

    [MVCColumn('DatumSchvaleni')]
    [MVCSwagJsonSchemaField(stDate, 'DatumSchvaleni', 'Datum schválení', false, true)]
    property DatumSchvaleni: NullableTDateTime read FDatumSchvaleni write FDatumSchvaleni;
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabZakazModifDilce')]
  TTPVZakazkovaModifikaceDilce = class(THeliosObjekty)
   private
    FIDZakazModif: integer;
    FIDKmenZbozi: integer;
    FNazev: NullableString;
    FTPVModif: boolean;
    FZKalkulModif: boolean;
    FPoznamka: NullableString;
    FKmenStredisko: NullableString;
    FRadaVyrPlanu: NullableString;
    FRadaVyrPrikazu: NullableString;
   public
    [MVCColumn('IDZakazModif')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZakazModif', 'Interní ID zakázkové modifikace', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDZakazModif: integer read FIDZakazModif write FIDZakazModif;

    [MVCColumn('IDKmenZbozi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKmenZbozi', 'Interni ID kmenove karty', true, false)]
    property IDKmenZbozi: integer read FIDKmenZbozi write FIDKmenZbozi;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název', false, true, 1, 100)]
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('TPVModif')]
    [MVCSwagJsonSchemaField(stBoolean, 'TPVModif', 'TPV modifikováno', true, false)]
    property TPVModif: boolean read FTPVModif write FTPVModif default false;

    [MVCColumn('ZKalkulModif')]
    [MVCSwagJsonSchemaField(stBoolean, 'ZKalkulModif', 'Modifikována kalkulace', true, false)]
    property ZKalkulModif: boolean read FZKalkulModif write FZKalkulModif default false;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('KmenoveStredisko')]
    [MVCSwagJsonSchemaField(stString, 'KmenoveStredisko', 'Kmenové středisko', false, true, 1, 30)]
    property KmenoveStredisko: NullableString read FKmenStredisko write FKmenStredisko;

    [MVCColumn('RadaVyrPlanu')]
    [MVCSwagJsonSchemaField(stString, 'RadaVyrPlanu', 'Řada výrobního plánu', false, true, 1, 10)]
    property RadaVyrPlanu: NullableString read FRadaVyrPlanu write FRadaVyrPlanu;

    [MVCColumn('RadaVyrPrikazu')]
    [MVCSwagJsonSchemaField(stString, 'RadaVyrPrikazu', 'Kmenové středisko', false, true, 1, 10)]
    property RadaVyrPrikazu: NullableString read FRadaVyrPrikazu write FRadaVyrPrikazu;
  end;



  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabVyrCisPrikaz')]
  TVyrCisPrikaz = class(THeliosObjekty)
   private
    FIDPrikaz: integer;
    FVyrCislo: string;
    FPopis: string;
    FDatExpirace: NullableTDateTime;
    FPoznamka: NullableString;
    FMnozstvi: Extended;
    FZmetky: Extended;
    FOdvedeno: Extended;
    FMnozstviZive: NullableExtended;
   protected
    procedure OnAfterLoad; override;
   public
    constructor Create; virtual;
    destructor Destroy; override;
{
    [MVCColumn('StavPrikazu')]
    [MVCSwagJsonSchemaField(stInteger, 'StavPrikazu', 'Stav vyrobniho prikazu', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property StavPrikazu: integer read FStavPrikazu write FStavPrikazu;
}
    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID výrobního příkazu', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('VyrCislo')]
    [MVCSwagJsonSchemaField(stString, 'VyrCislo', 'Výrobní číslo', true, false, 0, 100)]
    property VyrCislo: String read FVyrCislo write FVyrCislo;

    [MVCColumn('Popis')]
    [MVCSwagJsonSchemaField(stString, 'Popis', 'Popis výrobního čísla', true, false, 0, 100)]
    property Popis: String read FPopis write FPopis;

    [MVCColumn('DatExpirace')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatExpirace', 'Datum expirace', false, true)]
    property DatExpirace: NullableTDateTime read FDatExpirace write FDatExpirace;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, SizeOf(string))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('Mnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnozstvi', 'Množství', true, false)]
    property Mnozstvi: Extended read FMnozstvi write FMnozstvi;

    [MVCColumn('Zmetky')]
    [MVCSwagJsonSchemaField(stNumber, 'Zmetky', 'Zmetky', true, false)]
    property Zmetky: Extended read FZmetky write FZmetky;

    [MVCColumn('Odvedeno')]
    [MVCSwagJsonSchemaField(stNumber, 'Odvedeno', 'Odvedeno', true, false)]
    property Odvedeno: Extended read FOdvedeno write FOdvedeno;

    [MVCColumn('MnozstviZive')]
    [MVCSwagJsonSchemaField(stNumber, 'MnozstviZive', 'Množství živé', false, true)]
    property MnozstviZive: NullableExtended read FMnozstviZive write FMnozstviZive;
   end;




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPrikaz')]
  TVyrobniPrikaz = class(THeliosObjekty)
   private
    FStavPrikazu: integer;
    FRada: string;
    FCislo: integer;
    FIDZakazModif: NullableInt32;
    FKodZakazModif: NullableString;
    FIDPrikazVyssi: integer;
    FIDPrikazRidici: Integer;
    FIDTabKmen: integer;
    FSZ: string;
    FRegCis: string;
    FNazev1: string;
    FIDZakazka: NullableInt32;
    FCisloZakazky: NullableString;
    FKsZadane: Extended;
    FKsCiste: Extended;
    FKsZive: Extended;
    FPlanZadani: NullableTDateTime;
    FDatZadani: NullableTDateTime;
    FPlanUkonceni: NullableTDateTime;
    FDatUkonceni: NullableTDateTime;
    FEvidRozpracOperStart: NullableTDateTime;
    FVyrobniOperace: TObjectList<TVyrobniOperace>;
    FMaterial: TObjectList<TMaterialPrikazu>;
    FVyrobniCisla: TObjectList<TVyrCisPrikaz>;
    FNadrizenePrikazy: TObjectList<TVyrobaNadrizenePrikazy>;
    FPodrizenePrikazy: TObjectList<TVyrobaNadrizenePrikazy>;
    procedure SetVyrobniOperace (const Value: TObjectList<TVyrobniOperace>);
    procedure SetMaterialPrikazu (const Value: TObjectList<TMaterialPrikazu>);
    procedure SetVyrCisPrikazu (const Value: TObjectList<TVyrCisPrikaz>);
    procedure SetNadrizenePrikazy (const Value: TObjectList<TVyrobaNadrizenePrikazy>);
    procedure SetPodrizenePrikazy (const Value: TObjectList<TVyrobaNadrizenePrikazy>);
   public
    constructor Create; virtual;
    destructor Destroy; override;

    [MVCColumn('StavPrikazu')]
    [MVCSwagJsonSchemaField(stInteger, 'StavPrikazu', 'Stav vyrobniho prikazu', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property StavPrikazu: integer read FStavPrikazu write FStavPrikazu;

    [MVCColumn('IDTabKmen')]
    [MVCSwagJsonSchemaField(stInteger, 'IDTabKmen', 'Interni ID kmenove karty', true, false)]
    property IDTabKmen: integer read FIDTabKmen write FIDTabKmen;

    [MVCColumn('SZ')]
    [MVCSwagJsonSchemaField(stString, 'SZ', 'Skupina karet dílce', true, false, 3, 3)]
    property SZ: string read FSZ write FSZ;

    [MVCColumn('RegCis')]
    [MVCSwagJsonSchemaField(stString, 'RegCis', 'Reg.číslo dílce', true, false, 1, 30)]
    property RegCis: string read FRegCis write FRegCis;

    [MVCColumn('Nazev1')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1', 'Název 1 dílce', true, false, 1, 100)]
    property Nazev1: string read FNazev1 write FNazev1;

    [MVCColumn('IDZakazModif')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZakazModif', 'Interní ID zakázkové modifikace', false, true)]
    property IDZakazModif: NullableInt32 read FIDZakazModif write FIDZakazModif;

    [MVCColumn('KodZakazModif')]
    [MVCSwagJsonSchemaField(stString, 'KodZakazModif', 'Kód zakázkové modifikace', false, true)]
    property KodZakazModif: NullableString read FKodZakazModif write FKodZakazModif;

    [MVCColumn('IDZakazka')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZakazka', 'Interní ID zakázky', false, true)]
    property IDZakazka: NullableInt32 read FIDZakazka write FIDZakazka;

    [MVCColumn('CisloZakazky')]
    [MVCSwagJsonSchemaField(stString, 'CisloZakazky', 'Číslo zakázky', false, true)]
    property CisloZakazky: NullableString read FCisloZakazky write FCisloZakazky;

    [MVCColumn('Rada')]
    [MVCSwagJsonSchemaField(stString, 'Rada', 'Rada vyrobniho prikazu', true, false)]
    property Rada: string read FRada write FRada;

    [MVCColumn('Prikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'Prikaz', 'Cislo vyrobniho prikazu', true, false)]
    property Prikaz: integer read FCislo write FCislo;

    [MVCColumn('Kusy_zad')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zad', 'Kusy zadane', true, false)]
    property KusyZadane: Extended read FKsZadane write FKsZadane;

    [MVCColumn('Kusy_ciste')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_ciste', 'Kusy ciste', true, false)]
    property KusyCiste: Extended read FKsCiste write FKsCiste;

    [MVCColumn('Kusy_zive')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy_zive', 'Kusy zive', true, false)]
    property KusyZive: Extended read FKsZive write FKsZive;

    [MVCColumn('IDPrikazVyssi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikazVyssi', 'Interni ID vyssiho prikazu', false, true)]
    property IDPrikazVyssi: integer read FIDPrikazVyssi write FIDPrikazVyssi;

    [MVCColumn('IDPrikazRidici')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikazRidici', 'Interni ID ridiciho prikazu', false, false)]
    property IDPrikazRidici: integer read FIDPrikazRidici write FIDPrikazRidici;

    [MVCColumn('Plan_Zadani')]
    [MVCSwagJsonSchemaField(stDateTime, 'PlanZadani', 'Plánované zadání', false, true)]
    property PlanZadani: NullableTDateTime read FPlanZadani write FPlanZadani;

    [MVCColumn('zadani')]
    [MVCSwagJsonSchemaField(stDateTime, 'zadani', 'Plánované zadání', false, true)]
    property DatZadani: NullableTDateTime read FDatZadani write FDatZadani;

    [MVCColumn('Plan_Ukonceni')]
    [MVCSwagJsonSchemaField(stDateTime, 'Plan_Ukonceni', 'Plánované zadání', false, true)]
    property PlanUkonceni: NullableTDateTime read FPlanUkonceni write FPlanUkonceni;

    [MVCColumn('ukonceni')]
    [MVCSwagJsonSchemaField(stDateTime, 'ukonceni', 'Plánované zadání', false, true)]
    property DatUkonceni: NullableTDateTime read FDatUkonceni write FDatUkonceni;

    [MVCColumn('EvidRozpracOperStart')]
    [MVCSwagJsonSchemaField(stDateTime, 'EvidRozpracOperStart', 'Plánované zadání', false, true)]
    property EvidRozpracOperStart: NullableTDateTime read FEvidRozpracOperStart write FEvidRozpracOperStart;


    [MVCListOf(TVyrobniOperace)]
    property VyrobniOperace: TObjectList<TVyrobniOperace> read FVyrobniOperace write SetVyrobniOperace;

    [MVCListOf(TMaterialPrikazu)]
    property Material: TObjectList<TMaterialPrikazu> read FMaterial write SetMaterialPrikazu;

    [MVCListOf(TVyrCisPrikaz)]
    property VyrobniCisla: TObjectList<TVyrCisPrikaz> read FVyrobniCisla write SetVyrCisPrikazu;

    [MVCListOf(TVyrobaNadrizenePrikazy)]
    property NadrizenePrikazy: TObjectList<TVyrobaNadrizenePrikazy> read FNadrizenePrikazy write SetNadrizenePrikazy;

    [MVCListOf(TVyrobaNadrizenePrikazy)]
    property PodrizenePrikazy: TObjectList<TVyrobaNadrizenePrikazy> read FPodrizenePrikazy write SetPodrizenePrikazy;
  end;




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabEvidRozpracOperR')]
  TEvidRozpracOperaceOperace = class(THeliosObjekty)
   private
    FIDEvidRozpracOper: integer;
    FIDPrikaz: integer;
    FNazevDilce: NullableString;
    FSkupZboDilce: NullableString;
    FRegCisDilce: NullableString;
    FDokladPrPostup: integer;
    FAltPrPostup: char;
    FNazevOperace: NullableString;
    FOperace: string;
    FIDSdruzVyrOperaceR: NullableInt32;
    FIDVyrCis: NullableInt32;
    FTypEvidMnoz: NullableInt16;
    FMnoz_odv: NullableExtended;
    FSk_cas: NullableExtended;
    FSk_cas_T: byte;
    FSk_cas_Obsluhy: NullableExtended;
    FSk_cas_Obsluhy_T: byte;
    FPoznamka: NullableString;
    FJeSdruzenaOper: boolean;
    FOdvadeci: boolean;
{$IFDEF CUSTOM_CTRL_INCOSystems}
    FMamNeuzavrenePredchozi: boolean;
{$ENDIF}
   protected
    procedure OnAfterLoad; override;
   public
    constructor Create; virtual;

    [MVCColumn('IDEvidRozpracOper')]
    [MVCSwagJsonSchemaField(stInteger, 'IDEvidRozpracOper', 'Interní ID evidence rozpracovaných operací', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDEvidRozpracOper: integer read FIDEvidRozpracOper write FIDEvidRozpracOper;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'Interní ID výrobního příkazu', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('DokladPrPostup')]
    [MVCSwagJsonSchemaField(stInteger, 'DokladPrPostup', 'Doklad operace', true, false)]
    property DokladPrPostup: integer read FDokladPrPostup write FDokladPrPostup;

    [MVCColumn('AltPrPostup')]
    [MVCSwagJsonSchemaField(stChar, 'AltPrPostup', 'Alternativa operace', true, false)]
    property AltPrPostup: char read FAltPrPostup write FAltPrPostup;

    [MVCColumn('IDSdruzVyrOperaceR')]
    [MVCSwagJsonSchemaField(stInteger, 'IDSdruzVyrOperaceR', 'Interní ID sdružené operace', false, true)]
    property IDSdruzVyrOperaceR: NullableInt32 read FIDSdruzVyrOperaceR write FIDSdruzVyrOperaceR;

    [MVCColumn('IDVyrCis')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVyrCis', 'Interní ID výrobního čísla daného příkazu', false, true)]
    property IDVyrCis: NullableInt32 read FIDVyrCis write FIDVyrCis;

    [MVCColumn('Mnoz_odv')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnoz_odv', 'Evidované kusy dobré', false, true)]
    property Mnoz_odv: NullableExtended read FMnoz_odv write FMnoz_odv;

    [MVCColumn('Sk_cas')]
    [MVCSwagJsonSchemaField(stNumber, 'Sk_cas', 'Evidovaný čas', false, true)]
    property Sk_cas: NullableExtended read FSk_cas write FSk_cas;

    [MVCColumn('Sk_cas_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Sk_cas_T', 'Typ evidovaného času (0=sec / 1=min / 2=hod)', true, false)]
    property Sk_cas_T: byte read FSk_cas_T write FSk_cas_T;

    [MVCColumn('Sk_cas_Obsluhy')]
    [MVCSwagJsonSchemaField(stNumber, 'Sk_cas_Obsluhy', 'Evidovaný čas obsluhy', false, true)]
    property Sk_cas_Obsluhy: NullableExtended read FSk_cas_Obsluhy write FSk_cas_Obsluhy;

    [MVCColumn('Sk_cas_Obsluhy_T')]
    [MVCSwagJsonSchemaField(stInteger, 'Sk_cas_Obsluhy_T', 'Typ evidovaného času obsluhy (0=sec / 1=min / 2=hod)', true, false)]
    property Sk_cas_Obsluhy_T: byte read FSk_cas_Obsluhy_T write FSk_cas_Obsluhy_T;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('NazevOperace')]
    [MVCSwagJsonSchemaField(stString, 'NazevOperace', 'Název operace (z operací příkazu)', false, true, 0, 100)]
    property NazevOperace: NullableString read FNazevOperace write FNazevOperace;

    [MVCColumn('Nazev1Dilce')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1Dilce', 'Název vyráběného dílce', false, true, 0, 100)]
    property Nazev1Dilce: NullableString read FNazevDilce write FNazevDilce;

    [MVCColumn('SkupZboDilce')]
    [MVCSwagJsonSchemaField(stString, 'SkupZboDilce', 'Skupina karet vyráběného dílce', false, true, 0, 3)]
    property SkupZboDilce: NullableString read FSkupZboDilce write FSkupZboDilce;

    [MVCColumn('RegCisDilce')]
    [MVCSwagJsonSchemaField(stString, 'RegCisDilce', 'Registracni cislo vyráběného dílce', false, true, 0, 30)]
    property RegCisDilce: NullableString read FRegCisDilce write FRegCisDilce;

    [MVColumn('Odvadeci')]
    [MVCSwagJsonSchemaField(stBoolean, 'Odvadeci', 'Odváděcí operace', true, false)]
    property Odvadeci: boolean read FOdvadeci write FOdvadeci;

    [MVColumn('Operace')]
    [MVCSwagJsonSchemaField(stString, 'Operace', 'Operace', false, true, 0, 4)]
    property Operace: string read FOperace write FOperace;

{$IFDEF CUSTOM_CTRL_INCOSystems}
    [MVCColumn('MamNeuzavrenePredchozi')]
    [MVCSwagJsonSchemaField(stBoolean, 'MamNeuzavrenePredchozi', 'Existují neuzavřené rozpracované evidence operace daného příkazu s nižším číslem operace', true, false)]
    property MamNeuzavrenePredchozi: boolean read FMamNeuzavrenePredchozi write FMamNeuzavrenePredchozi;
{$ENDIF}
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabEvidRozpracOper')]
  TEvidRozpracOperace = class(THeliosObjekty)
   private
    FDatumPripadu: TDateTime;
    FDatumUzavreni: NullableTDateTime;
    FAutorUzavreni: NullableString;
    FIDZamestnance: NullableInt32;
    FCasZahajeni: NullableTDateTime;
    FCasUkonceni: NullableTDateTime;
    FIDSmeny: NullableInt32;
    FIDPracoviste: NullableInt32;
    FKodPracoviste: NullableString;
    FNazevPracoviste: NullableString;
    FIDStroje: NullableInt32;
    FKodStroje: NullableString;
    FNazevStroje: NullableString;
    FKVO: Extended;
    FIDEvidRozpracOperProstoje: NullableInt32;
    FPoznamka: NullableString;
    FStav: NullableInt16;
    FCelkovyCas: NullableExtended;
    FCelkovyCas_T: byte;
    FCelkovyCas_S: Extended;
    FCelkovyCas_N: Extended;
    FCelkovyCas_H: Extended;
    FOperace: TObjectList<TEvidRozpracOperaceOperace>;
    procedure SetOperace (const Value: TObjectList<TEvidRozpracOperaceOperace>);
   protected
    procedure OnAfterLoad; override;
   public
    constructor Create; virtual;
    destructor Destroy; override;

    [MVCColumn('DatumPripadu')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumPripadu', 'Datum případu', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property DatumPripadu: TDateTime read FDatumPripadu write FDatumPripadu;

    [MVCColumn('DatumUzavreni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumUzavreni', 'Datum uzavření', false, true)]
    property DatumUzavreni: NullableTDateTime read FDatumUzavreni write FDatumUzavreni;

    [MVCColumn('AutorUzavreni')]
    [MVCSwagJsonSchemaField(stString, 'AutorUzavreni', 'Autor uzavření', false, true, 0, 128)]
    property AutorUzavreni: NullableString read FAutorUzavreni write FAutorUzavreni;

    [MVCColumn('IDZamestnance')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZamestnance', 'Interní ID zaměstnance', false, true)]
    property IDZamestnance: NullableInt32 read FIDZamestnance write FIDZamestnance;

    [MVCColumn('CasZahajeni')]
    [MVCSwagJsonSchemaField(stDateTime, 'CasZahajeni', 'Čas zahájení evidence', false, true)]
    property CasZahajeni: NullableTDateTime read FCasZahajeni write FCasZahajeni;

    [MVCColumn('CasUkonceni')]
    [MVCSwagJsonSchemaField(stDateTime, 'CasUkonceni', 'Čas ukončení evidence', false, true)]
    property CasUkonceni: NullableTDateTime read FCasUkonceni write FCasUkonceni;

    [MVCColumn('IDSmeny')]
    [MVCSwagJsonSchemaField(stInteger, 'IDSmeny', 'Interní ID směny', false, true)]
    property IDSmeny: NullableInt32 read FIDSmeny write FIDSmeny;

    [MVCColumn('IDPracoviste')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPracoviste', 'Interní ID praoviště', false, true)]
    property IDPracoviste: NullableInt32 read FIDPracoviste write FIDPracoviste;

    [MVCColumn('KodPracoviste')]
    [MVCSwagJsonSchemaField(stString, 'KodPracoviste', 'Kód pracoviště (pokud je v evidenci zadáno)', false, true, 0, 10)]
    property KodPracoviste: NullableString read FKodStroje write FKodStroje;

    [MVCColumn('NazevPracoviste')]
    [MVCSwagJsonSchemaField(stString, 'NazevPracoviste', 'Název pracoviště (pokud je v evidenci zadáno)', false, true, 0, 40)]
    property NazevPracoviste: NullableString read FNazevPracoviste write FNazevPracoviste;

    [MVCColumn('IDStroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStroje', 'Interní ID stroje', false, true)]
    property IDStroje: NullableInt32 read FIDStroje write FIDStroje;

    [MVCColumn('KodStroje')]
    [MVCSwagJsonSchemaField(stString, 'KodStroje', 'Kód stroje (pokud je v evidenci zadán)', false, true, 0, 10)]
    property KodStroje: NullableString read FKodStroje write FKodStroje;

    [MVCColumn('NazevStroje')]
    [MVCSwagJsonSchemaField(stString, 'NazevStroje', 'Název stroje (pokud je v evidenci zadán)', false, true, 0, 40)]
    property NazevStroje: NullableString read FNazevStroje write FNazevStroje;

    [MVCColumn('KVO')]
    [MVCSwagJsonSchemaField(stNumber, 'KVO', 'Koeficient vícestrojové obsluhy', true, false)]
    property KVO: Extended read FKVO write FKVO;

    [MVCColumn('IDEvidRozpracOperProstoje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDEvidRozpracOperProstoje', 'Interní ID prostoje evidence rozpracovaných operací', false, true)]
    property IDEvidRozpracOperProstoje: NullableInt32 read FIDEvidRozpracOperProstoje write FIDEvidRozpracOperProstoje;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('CelkovyCas')]
    [MVCSwagJsonSchemaField(stNumber, 'CelkovyCas', 'Celkový evidovaného čas', false, true)]
    property CelkovyCas: NullableExtended read FCelkovyCas write FCelkovyCas;

    [MVCColumn('CelkovyCas_T')]
    [MVCSwagJsonSchemaField(stInteger, 'CelkovyCas_T', 'Typ celkového evidovaného času (0=sec / 1=min / 2=hod)', true, false)]
    property CelkovyCas_T: byte read FCelkovyCas_T write FCelkovyCas_T;

    [MVCColumn('Stav')]
    [MVCSwagJsonSchemaField(stInteger, 'Stav', 'Stav (10=pořízeno, 20=zahájeno, 25=prostoj, 26=prostoj obsluhy, 27=prostoj stroje, 30=ukončeno, 40=uzavřeno', false, true)]
    property Stav: NullableInt16 read FStav write FStav;

    [MVCListOf(TEvidRozpracOperaceOperace)]
    property Operace: TObjectList<TEvidRozpracOperaceOperace> read FOperace write SetOperace;
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabKVazby')]
  TTPVKusovnikDilce = class(THeliosObjekty)
   private
    FIDPrKVazby: Integer;
    FIDVyssi: Integer;
    FMNF: Extended;
    Fmnozstvi: Extended;
    FPoradi: Integer;
    FIDPrikaz: Integer;
    FIDKmenPolozky: Integer;
    FSZNizsi: string;
    FRCNizsi: string;
    FNazev1Nizsi: string;
    FMJNizsi: NullableString;
    FIDZakazModif: NullableInt32;
   public
    [MVCColumn('IDKVazby')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKVazby', 'ID kusovníkove vazby', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDKVazby: Integer read FIDPrKVazby write FIDPrKVazby;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'IDPrikaz', true, false)]
    property IDPrikaz: Integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('Poradi')]
    [MVCSwagJsonSchemaField(stInteger, 'Poradi', 'Pořadí v rámci úrovně', true, false)]
    property Poradi: Integer read FPoradi write FPoradi;

    [MVCColumn('MNF')]
    [MVCSwagJsonSchemaField(stNumber, 'MNF', 'Požadovaný počet finálů', true, false)]
    property MNF: Extended read FMNF write FMNF;

    [MVCColumn('Mnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'Mnozstvi', 'Požadované množství na finál', true, false)]
    property Mnozstvi: Extended read FMnozstvi write FMnozstvi;

    [MVCColumn('Vyssi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKmenVyssi', 'ID vyšší kmenové karty dílce', true, false)]
    property IDKmenVyssi: Integer read FIDVyssi write FIDVyssi;

    [MVCColumn('IDKmenZbozi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKmenNizsi', 'ID kmenové karty dílce/materiálu položky kusovníku', true, false)]
    property IDKmenNizsi: Integer read FIDKmenPolozky write FIDKmenPolozky;

    [MVCColumn('SZNizsi')]
    [MVCSwagJsonSchemaField(stString, 'SZVyssi', 'SK nižší karty', true, false, 1, 3)]
    property SZNizsi: string read FSZNizsi write FSZNizsi;

    [MVCColumn('RCNizsi')]
    [MVCSwagJsonSchemaField(stString, 'RCNizsi', 'Reg. číslo nižší karty', true, false, 1, 30)]
    property RCNizsi: string read FRCNizsi write FRCNizsi;

    [MVCColumn('Nazev1Nizsi')]
    [MVCSwagJsonSchemaField(stString, 'Nazev1Nizsi', 'Název 1 nižší karty', true, false, 0, 100)]
    property Nazev1Nizsi: string read FNazev1Nizsi write FNazev1Nizsi;

    [MVCColumn('MJNizsi')]
    [MVCSwagJsonSchemaField(stString, 'MJNizsi', 'MJ nižší karty', true, false, 0, 10)]
    property MJNizsi: NullableString read FMJNizsi write FMJNizsi;

    [MVCColumn('IDZakazModif')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZakazModif', 'Interní ID zakázkové modifikace', false, true)]
    property IDZakazModif: NullableInt32 read FIDZakazModif write FIDZakazModif;
  end;




  [MVCNameCase(ncLowerCase)]
  TTPVPracoviste = class(THeliosObjekty)
   private
    FPracoviste: string;
    FNazev: string;
    FStredisko: string;
    FBarva: integer;
   public
    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název pracoviště', true, false, 0, 40)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Nazev: string read FNazev write FNazev;

    [MVCColumn('IDTabStrom')] // nazev v tabulce
    [MVCTableField('Stredisko')] // nazev pro API
    [MVCSwagJsonSchemaField(stString, 'Stredisko', 'Středisko pracoviště', true, false, 1, 30)]
    property Stredisko: string read FStredisko write FStredisko;

    [MVCColumn('Pracoviste')]
    [MVCSwagJsonSchemaField(stString, 'Pracoviste', 'Kód pracoviště', true, false, 1, 10)]
    property Pracoviste: string read FPracoviste write FPracoviste;

    [MVCColumn('Barva')]
    [MVCTableField('Barva')]
    [MVCSwagJsonSchemaField(stString, 'Barva', 'Barva pracoviště', false, true)]
    property Barva: integer read FBarva write FBarva;
  end;





  [MVCNameCase(ncLowerCase)]
  TTPVCiselnikZmen = class(THeliosObjekty)
   private
    FRada: string;
    FCisloZmeny: string;
    FNavrh: NullableString;
    FOsCislo: NullableInt32;
    FPoznamka: NullableString;
    FDatum: TDateTime;
    FAutorPlatnosti: NullableString;
    FDatumNastaveni: NullableTDateTime;
    FPlatnost: Boolean;
    FPermanentniZmena: Boolean;
    FIntPermanentniZmena: Boolean;
    FLogins: NullableString;
    FRunning: Boolean;
    FAutor: string;
    FDatPorizeni: TDateTime;
    FZmenil: NullableString;
    FDatZmeny: NullableTDateTime;
    FPlatnostTPV: Boolean;
    FBlokDP: Boolean;
    FDocasnaPlatnost: Boolean;
    procedure SetPlatnostTPV(const Value: Boolean);
    procedure SetLogins(const Value: NullableString);
   public
    [MVCColumn('Rada')]
    [MVCSwagJsonSchemaField(stString, 'Rada', 'Řada', true, false, 0, 10)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Rada: string read FRada write FRada;

    [MVCColumn('ciszmeny')]
    [MVCSwagJsonSchemaField(stString, 'CisloZmeny', 'Číslo změny', true, false, 0, 15)]
    property CisloZmeny: string read FCisloZmeny write FCisloZmeny;

    [MVCColumn('Navrh')]
    [MVCSwagJsonSchemaField(stString, 'Navrh', 'Identifikace návrhu změny', false, true, 0, 40)]
    property Navrh: NullableString read FNavrh write FNavrh;

    [MVCColumn('os_cislo')]
    [MVCSwagJsonSchemaField(stInteger, 'OsCislo', 'ID číslo zodpovědného zaměstnance za změnu', false, true)]
    property OsCislo: NullableInt32 read FOsCislo write FOsCislo;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true, 0, 65535)]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('Datum')]
    [MVCSwagJsonSchemaField(stDateTime, 'Datum', 'Datum, od kterého změna platí', true, false)]
    property Datum: TDateTime read FDatum write FDatum;

    [MVCColumn('AutorPlatnosti')]
    [MVCSwagJsonSchemaField(stString, 'AutorPlatnosti', 'Autor platnosti', false, true, 0, 128)]
    property AutorPlatnosti: NullableString read FAutorPlatnosti write FAutorPlatnosti;

    [MVCColumn('DatumNastaveni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumNastaveni', 'Datum a čas zpoplatnění změny', false, true)]
    property DatumNastaveni: NullableTDateTime read FDatumNastaveni write FDatumNastaveni;

    [MVCColumn('Logins')]
    [MVCSwagJsonSchemaField(stString, 'Logins', 'Logins', false, true, 0, 128)]
    property Logins: NullableString read FLogins write SetLogins;
    property BlokDP: boolean read FBlokDP write FBlokDP;

    [MVCColumn('Platnost')]
    [MVCSwagJsonSchemaField(stBoolean, 'Platnost', 'Příznak platnosti změny', true, false)]
    property Platnost: boolean read FPlatnost write SetPlatnostTPV default false;
    property PlatnostTPV: boolean read FPlatnostTPV write FPlatnostTPV;

  end;



  [MVCNameCase(ncLowerCase)]
  TTPVStroj = class(THeliosObjekty)
   private
    FIDPrac: integer;
    FPracoviste: string;
    FKod: string;
    FNazev: NullableString;
    FBlokovano: boolean;
    FIDKalendar: NullableInt32;
    FAdvKPlan: Boolean;
   public
    [MVCColumn('Kod')]
    [MVCSwagJsonSchemaField(stString, 'Kod', 'Kód stroje', true, false, 0, 10)]
    property Kod: string read FKod write FKod;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název stroje', false, true, 0, 40)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('IDPrac')]
    [MVCSwagJsonSchemaField(stString, 'IDPrac', 'ID pracoviště', true, false)]
    property IDPrac: integer read FIDPrac write FIDPrac;

    [MVCColumn('Blokovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Blokovano', 'Stroj je pro použití ve výrobě blokovaný', true, false)]
    property Blokovano: boolean read FBlokovano write FBlokovano default false;

    [MVCColumn('IDPlanKalend')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKalendar', 'ID plánovacího kalendáře stroje', false, true)]
    property IDKalendar: NullableInt32 read FIDKalendar write FIDKalendar;

    [MVCColumn('pracoviste')]
    [MVCSwagJsonSchemaField(stString, 'Pracoviste', 'Pracoviště', true, false, 0, 10)]
    property pracoviste: string read FPracoviste write FPracoviste;

    [MVCColumn('Konf_ZahrnoutDoKapacPlan')] // nazev ze SELECTu
    [MVCSwagJsonSchemaField(stBoolean, 'AdvKPlan', 'Zahrnout do kapacitního plánování', true, false)]
    property AdvKPlan: boolean read FAdvKPlan write FAdvKPlan default false;
  end;




  [MVCNameCase(ncLowerCase)]
  TDataZoneTask = class(THeliosObjekty)
   private
    FDeviceID: NullableString;
    FDZTaskID: integer;
    FChybaEvidence: string;
    FBarcode: string;
   public
    [MVCColumn('IdDataZoneTaskID')]
    [MVCSwagJsonSchemaField(stInteger, 'DataZoneTaskID', 'ID tasku DataZone', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property DataZoneTaskID: integer read FDZTaskID write FDZTaskID;

    [MVCColumn('PosledniChyba')]
    [MVCSwagJsonSchemaField(stInteger, 'TextChybyEvidence', 'Poslední chyba při evidenci', true, false, 0, 255)]
    property TextChybyEvidence: string read FChybaEvidence write FChybaEvidence;

    [MVCColumn('DeviceID')]
    [MVCSwagJsonSchemaField(stInteger, 'DeviceID', 'ID DataZone zařízení', false, true, 0, 30)]
    property DeviceID: NullableString read FDeviceID write FDeviceID;

    [MVCColumn('Barcode')]
    [MVCSwagJsonSchemaField(stInteger, 'Barcode', 'Barcode operace', true, false, 0, 30)]
    property Barcode: string read FBarcode write FBarcode;
  end;




  [MVCNameCase(ncLowerCase)]
  TTPVPrednastaveniOperaci = class(THeliosObjekty)
   private
    FTyp: integer;
    FNazev: string;
    FIDPracoviste: NullableInt32;
    FIDStroje: NullableInt32;
    FIDKooperace: NullableInt32;
    FTarif: NullableInt32;

    FTBC: NullableExtended;
    FTBC_T: byte;
    FTBC_Obsluhy: NullableExtended;
    FTBC_Obsluhy_T: byte;
    FTBC_S: NullableExtended;
    FTBC_N: NullableExtended;
    FTBC_H: NullableExtended;

    FTEC: NullableExtended;
    FTEC_T: byte;
    FTEC_S: NullableExtended;
    FTEC_N: NullableExtended;
    FTEC_H: NullableExtended;

    FTEC_KC: Extended;

    FTAC_J: NullableExtended;
    FTAC_J_T: byte;
    FTAC_J_S: NullableExtended;
    FTAC_J_N: NullableExtended;
    FTAC_J_H: NullableExtended;

    FTAC_KC_J: Extended;

    FPoznamka: NullableString;

    FNasobekTAC: Extended;
    FKoopMnozstvi: Extended;
    FPocetLidi: integer;
    FPocetKusu: integer;
    FPocetStroju: integer;

    FIDObrazek: NullableInt32;
    FZpusobZaplanovani: NullableInt16;
    FPlanDavka: NullableExtended;
    FMeziOperCas: NullableExtended;
    FMeziOperCas_T: byte;
    FMeziOperCas_S: NullableExtended;
    FMeziOperCas_N: NullableExtended;
    FMeziOperCas_H: NullableExtended;
    Fvseobecny: boolean;

   public
    constructor Create; virtual;

    [MVCColumn('Typ')]
    [MVCSwagJsonSchemaField(stInteger, 'Typ', 'Typ operace (0=Režijní operace/1=Jednicová operace/2=Kooperace)', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Typ: integer read FTyp write FTyp;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název operace', true, false, 0, 100)]
    property Nazev: string read FNazev write FNazev;

    [MVCColumn('IDpracoviste')]
    [MVCSwagJsonSchemaField(stInteger, 'IDpracoviste', 'ID pracoviště', false, true)]
    property IDPracoviste: NullableInt32 read FIDPracoviste write FIDPracoviste;

    [MVCColumn('IDStroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStroje', 'ID stroje', false, true)]
    property IDStroje: NullableInt32 read FIDStroje write FIDStroje;

    [MVCColumn('IDKooperace')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKooperace', 'ID kooperace', false, true)]
    property IDKooperace: NullableInt32 read FIDKooperace write FIDKooperace;

    [MVCColumn('Tarif')]
    [MVCSwagJsonSchemaField(stInteger, 'tarif', 'ID tarifu', false, true)]
    property Tarif: NullableInt32 read FTarif write FTarif;

    [MVCColumn('TBC')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC', 'Přípravný čas strojní', true, false)]
    property TBC: NullableExtended read FTBC write FTBC;

    [MVCColumn('TBC_T')]
    [MVCSwagJsonSchemaField(stInteger, 'TBC_T', 'Typ přípravného času (0=sec/1=min/2=hod)', true, false)]
    property TBC_T: byte read FTBC_T write FTBC_T;

    [MVCColumn('TBC_S')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_S', 'Přípravný čas (sec)', false, true)]
    property TBC_S: NullableExtended read FTBC_S write FTBC_S;

    [MVCColumn('TBC_N')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_N', 'Přípravný čas (min)', false, true)]
    property TBC_N: NullableExtended read FTBC_N write FTBC_N;

    [MVCColumn('TBC_H')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_H', 'Přípravný čas (hod)', false, true)]
    property TBC_H: NullableExtended read FTBC_H write FTBC_H;

    [MVCColumn('TBC_Obsluhy')]
    [MVCSwagJsonSchemaField(stNumber, 'TBC_Obsluhy', 'Přípravný čas obsluhy', true, false)]
    property TBC_Obsluhy: NullableExtended read FTBC_Obsluhy write FTBC_Obsluhy;

    [MVCColumn('TBC_Obsluhy_T')]
    [MVCSwagJsonSchemaField(stInteger, 'TBC_Obsluhy_T', 'Typ přípravného času obsluhy (0=sec/1=min/2=hod)', true, false)]
    property TBC_Obsluhy_T: byte read FTBC_Obsluhy_T write FTBC_Obsluhy_T;

    [MVCColumn('TEC')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC', 'Ukončovací čas strojní', true, false)]
    property TEC: NullableExtended read FTEC write FTEC;

    [MVCColumn('TEC_T')]
    [MVCSwagJsonSchemaField(stInteger, 'TEC_T', 'Typ ukončovacího času (0=sec/1=min/2=hod)', true, false)]
    property TEC_T: byte read FTEC_T write FTEC_T;

    [MVCColumn('TEC_S')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_S', 'Ukončovací čas (sec)', false, true)]
    property TEC_S: NullableExtended read FTEC_S write FTEC_S;

    [MVCColumn('TEC_N')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_N', 'Ukončovací čas (min)', false, true)]
    property TEC_N: NullableExtended read FTEC_N write FTEC_N;

    [MVCColumn('TEC_H')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_H', 'Ukončovací čas (hod)', false, true)]
    property TEC_H: NullableExtended read FTEC_H write FTEC_H;

    [MVCColumn('TEC_KC')]
    [MVCSwagJsonSchemaField(stNumber, 'TEC_KC', 'Ukončovací mzda', true, false)]
    property TEC_KC: Extended read FTEC_KC write FTEC_KC;

    [MVCColumn('NasobekTAC')]
    [MVCSwagJsonSchemaField(stNumber, 'NasobekTAC', 'Násobek TAC', true, false)]
    property NasobekTAC: Extended read FNasobekTAC write FNasobekTAC;

    [MVCColumn('TAC_J')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J', 'Jednicový čas', true, false)]
    property TAC_J: NullableExtended read FTAC_J write FTAC_J;

    [MVCColumn('TAC_J_T')]
    [MVCSwagJsonSchemaField(stInteger, 'TAC_J_T', 'Typ jednicového času (0=sec/1=min/2=hod)', true, false)]
    property TAC_J_T: byte read FTAC_J_T write FTAC_J_T;

    [MVCColumn('TAC_J_S')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J_S', 'Jednicový čas (sec)', false, true)]
    property TAC_J_S: NullableExtended read FTAC_J_S write FTAC_J_S;

    [MVCColumn('TAC_J_N')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J_N', 'Jednicový čas (min)', false, true)]
    property TAC_J_N: NullableExtended read FTAC_J_N write FTAC_J_N;

    [MVCColumn('TAC_J_H')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_J_H', 'Jednicový čas (hod)', false, true)]
    property TAC_J_H: NullableExtended read FTAC_J_H write FTAC_J_H;

    [MVCColumn('TAC_KC_J')]
    [MVCSwagJsonSchemaField(stNumber, 'TAC_KC_J', 'Jednicová mzda (jednotková)', true, false)]
    property TAC_KC_J: Extended read FTAC_KC_J write FTAC_KC_J;

    [MVCColumn('KoopMnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'KoopMnozstvi', 'Kooperační množství', true, false)]
    property KoopMnozstvi: Extended read FKoopMnozstvi write FKoopMnozstvi;

    [MVCColumn('PocetLidi')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetLidi', 'Počet lidí', true, false)]
    property PocetLidi: integer read FPocetLidi write FPocetLidi;

    [MVCColumn('PocetKusu')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetKusu', 'Počet kusů', true, false)]
    property PocetKusu: integer read FPocetKusu write FPocetKusu;

    [MVCColumn('PocetStroju')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetStroju', 'Počet strojů', true, false)]
    property PocetStroju: integer read FPocetStroju write FPocetStroju;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Potvrzený termín dodání', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;
  end;


  [MVCNameCase(ncLowerCase)]
  TKooperacniObjednavkaPolozka = class(THeliosObjekty)
   private
    FIDObjednavky: integer;
    FPolozka: integer;
    FIDPrikaz: integer;
    FDokladPrPostup: integer;
    FAltPrPostup: char;
    FIDkooperace: integer;
    FSplneno: boolean;
    FUzavreno: Boolean;
    FDavkaTPV: Extended;
    FKoopMnozstvi: Extended;
    FCelkKoopMnozstvi: NullableExtended;
    FKusy: extended;
    FKusyPrevedene: Extended;
    FKusyVKoop: Extended;
    FCena: Extended;
    FPocetPrepravDavek: Extended;
    FPozadTerDod: NullableTDateTime;
    FPotvrzTerDod: NullableTDateTime;
    FPoznamka: NullableString;
    FDatPorizeni: TDatetime;
    FAutor: String;
    FDatZmeny: NullableTDateTime;
    FZmenil: NullableString;
    FBarCode: NullableString;
   public
    constructor Create; virtual;

    [MVCColumn('IDObjednavky')]
    [MVCSwagJsonSchemaField(stInteger, 'IDObjednavky', 'Vazba na hlavičku Kooperační objednávky', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDObjednavky: integer read FIDObjednavky write FIDObjednavky;

    [MVCColumn('Polozka')]
    [MVCSwagJsonSchemaField(stInteger, 'Polozka', 'Pořadové číslo', true, false)]
    property Polozka: integer read FPolozka write FPolozka;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'Vazba na výrobní příkaz', true, false)]
    property IDPrikaz: integer read FIDPrikaz write FIDPrikaz;

    [MVCColumn('DokladPrPostup')]
    [MVCSwagJsonSchemaField(stInteger, 'DokladPrPostup', 'Doklad PrPostupu', true, false)]
    property DokladPrPostup: integer read FDokladPrPostup write FDokladPrPostup;

    [MVCColumn('AltPrPostup')]
    [MVCSwagJsonSchemaField(stChar, 'AltPrPostup', 'Alternativa A..Z', true, false)]
    property AltPrPostup: char read FAltPrPostup write FAltPrPostup;

    [MVCColumn('IDkooperace')]
    [MVCSwagJsonSchemaField(stInteger, 'IDkooperace', 'Vazba na výrobní příkaz', true, false)]
    property IDkooperace: integer read FIDkooperace write FIDkooperace;

    [MVCColumn('Splneno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Splneno', 'Splněno', true, false)]
    property Splneno: boolean read FSplneno write FSplneno;

    [MVCColumn('Uzavreno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Uzavreno', 'Uzavřeno', true, false)]
    property Uzavreno: boolean read FUzavreno write FUzavreno;

    [MVCColumn('KoopMnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'KoopMnozstvi', 'Kooperační množství', true, false)]
    property KoopMnozstvi: Extended read FKoopMnozstvi write FKoopMnozstvi;

    [MVCColumn('DavkaTPV')]
    [MVCSwagJsonSchemaField(stNumber, 'DavkaTPV', 'Konstrukční a technologická dávka', true, false)]
    property DavkaTPV: Extended read FDavkaTPV write FDavkaTPV;

    [MVCColumn('CelkKoopMnozstvi')]
    [MVCSwagJsonSchemaField(stNumber, 'CelkKoopMnozstvi', 'Celkové kooperační množství', false, true)]
    property CelkKoopMnozstvi: NullableExtended read FCelkKoopMnozstvi write FCelkKoopMnozstvi;

    [MVCColumn('Kusy')]
    [MVCSwagJsonSchemaField(stNumber, 'Kusy', 'Kusy', true, false)]
    property Kusy: Extended read FKusy write FKusy;

    [MVCColumn('KusyPrevedene')]
    [MVCSwagJsonSchemaField(stNumber, 'KusyPrevedene', 'Kusy převedené', true, false)]
    property KusyPrevedene: Extended read FKusyPrevedene write FKusyPrevedene;

    [MVCColumn('KusyVKoop')]
    [MVCSwagJsonSchemaField(stNumber, 'KusyVKoop', 'Kusy v kooperaci (tj. zůstatek ještě nepřijatý od kooperanta)', true, false)]
    property KusyVKoop: Extended read FKusyVKoop write FKusyVKoop;

    [MVCColumn('Cena')]
    [MVCSwagJsonSchemaField(stNumber, 'Cena', 'Cena', true, false)]
    property Cena: Extended read FCena write FCena;

    [MVCColumn('PocetPrepravDavek')]
    [MVCSwagJsonSchemaField(stNumber, 'PocetPrepravDavek', 'Počet přepravních dávek', true, false)]
    property PocetPrepravDavek: Extended read FPocetPrepravDavek write FPocetPrepravDavek;

    [MVCColumn('PozadTerDod')]
    [MVCSwagJsonSchemaField(stDateTime, 'PozadTerDod', 'Požadovaný termín dodání', false, true)]
    property PozadTerDod: NullableTDateTime read FPozadTerDod write FPozadTerDod;

    [MVCColumn('PotvrzTerDod')]
    [MVCSwagJsonSchemaField(stDateTime, 'PotvrzTerDod', 'Potvrzený termín dodání', false, true)]
    property PotvrzTerDod: NullableTDateTime read FPotvrzTerDod write FPotvrzTerDod;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Potvrzený termín dodání', false, true, 0, SizeOf(String))]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('BarCode')]
    [MVCSwagJsonSchemaField(stString, 'BarCode', 'Čárový kód ("B1" + id položky + "B")', true, false, 0, 15)]
    property BarCode: NullableString read FBarCode write FBarCode;
  end;




  [MVCNameCase(ncLowerCase)]
  TKooperacniObjednavka = class(THeliosObjekty)
   private
    FRealizovano: boolean;
    FUzavreno: boolean;
    FSplneno: boolean;
    FPolSplneny: boolean;
    FRada: string;
    FCislo: integer;
    FIDOrganizace: NullableInt32;
    FPozadTermDod: NullableTDateTime;
    FPotvrzTermDod: NullableTDateTime;
    FObjednavka: NullableString;
    FFormaUhrady: NullableString;
    FFormaDopravy: NullableString;
    FCenaPolozek: Extended;
    FCenaPolozekHM: Extended;
    FCenaPrepravy: Extended;
    FCenaPrepravyHM: Extended;
    FMena: string;
    FKurz: Extended;
    FJednotkaMeny: integer;
    FVstupniCena: integer;
    FDatumKurzu: NullableTDateTime;
    FPolozkyKoopObj: TObjectList<TKooperacniObjednavkaPolozka>;
    procedure SetPolozkyKoopObj(const Value: TObjectList<TKooperacniObjednavkaPolozka>);
   public
    constructor Create; virtual;
    destructor Destroy; override;

    [MVCColumn('Realizovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Realizovano', 'Realizováno', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Realizovano: boolean read FRealizovano write FRealizovano;

    [MVCColumn('Uzavreno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Uzavreno', 'Uzavřeno', true, false)]
    property Uzavreno: boolean read FUzavreno write FUzavreno;

    [MVCColumn('Splneno')]
    [MVCSwagJsonSchemaField(stBoolean, 'Splneno', 'Splněno', true, false)]
    property Splneno: boolean read FSplneno write FSplneno;

    [MVCColumn('PolSplneny')]
    [MVCSwagJsonSchemaField(stBoolean, 'PolSplneny', 'Položky splněny', true, false)]
    property PolSplneny: boolean read FPolSplneny write FPolSplneny;

    [MVCColumn('Rada')]
    [MVCSwagJsonSchemaField(stString, 'Rada', 'Řada kooperační objedávky', true, false)]
    property Rada: string read FRada write FRada;

    [MVCColumn('Cislo')]
    [MVCSwagJsonSchemaField(stInteger, 'Cislo', 'Číslo kooperační objedávky', true, false)]
    property Cislo: integer read FCislo write FCislo;

    [MVCColumn('IDOrganizace')]
    [MVCSwagJsonSchemaField(stInteger, 'IDOrganizace', 'ID organizace', false, true)]
    property IDOrganizace: NullableInt32 read FIDOrganizace write FIDOrganizace;

    [MVCColumn('PozadTermDod')]
    [MVCSwagJsonSchemaField(stDateTime, 'PozadTermDod', 'Požadovaný termín dodání', false, true)]
    property PozadTermDod: NullableTDateTime read FPozadTermDod write FPozadTermDod;

    [MVCColumn('PotvrzTermDod')]
    [MVCSwagJsonSchemaField(stDateTime, 'PotvrzTermDod', 'Potvrzený termín dodání', false, true)]
    property PotvrzTermDod: NullableTDateTime read FPotvrzTermDod write FPotvrzTermDod;

    [MVCColumn('Objednavka')]
    [MVCSwagJsonSchemaField(stString, 'Objednavka', 'Objednávka', false, true, 0, 20)]
    property Objednavka: NullableString read FObjednavka write FObjednavka;

    [MVCColumn('FormaUhrady')]
    [MVCSwagJsonSchemaField(stString, 'FormaUhrady', 'Forma úhrady', false, true, 0, 30)]
    property FormaUhrady: NullableString read FFormaUhrady write FFormaUhrady;

    [MVCColumn('FormaDopravy')]
    [MVCSwagJsonSchemaField(stString, 'FormaDopravy', 'Forma dopravy', false, true, 0, 30)]
    property FormaDopravy: NullableString read FFormaDopravy write FFormaDopravy;

    [MVCColumn('CenaPolozek')]
    [MVCSwagJsonSchemaField(stNumber, 'CenaPolozek', 'Cena položek', true, false)]
    property CenaPolozek: Extended read FCenaPolozek write FCenaPolozek;

    [MVCColumn('CenaPolozekHM')]
    [MVCSwagJsonSchemaField(stNumber, 'CenaPolozekHM', 'Cena položek (v hlavní měně)', true, false)]
    property CenaPolozekHM: Extended read FCenaPolozekHM write FCenaPolozekHM;

    [MVCColumn('CenaPrepravy')]
    [MVCSwagJsonSchemaField(stNumber, 'CenaPrepravy', 'Cena přepravy', true, false)]
    property CenaPrepravy: Extended read FCenaPrepravy write FCenaPrepravy;

    [MVCColumn('CenaPrepravyHM')]
    [MVCSwagJsonSchemaField(stNumber, 'CenaPrepravyHM', 'Cena přepravy (v hlavní měně)', true, false)]
    property CenaPrepravyHM: Extended read FCenaPrepravyHM write FCenaPrepravyHM;

    [MVCColumn('Mena')]
    [MVCSwagJsonSchemaField(stString, 'Mena', 'Měna', false, true, 0, 3)]
    property Mena: string read FMena write FMena;

    [MVCColumn('Kurz')]
    [MVCSwagJsonSchemaField(stNumber, 'Kurz', 'Kurz', true, false)]
    property Kurz: Extended read FKurz write FKurz;

    [MVCColumn('DatumKurzu')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumKurzu', 'Datum kurzu', false, true)]
    property DatumKurzu: NullableTDateTime read FDatumKurzu write FDatumKurzu;

    [MVCColumn('JednotkaMeny')]
    [MVCSwagJsonSchemaField(stInteger, 'JednotkaMeny', 'Jednotka měny', true, false)]
    property JednotkaMeny: integer read FJednotkaMeny write FJednotkaMeny;

    [MVCColumn('VstupniCena')]
    [MVCSwagJsonSchemaField(stInteger, 'VstupniCena', 'Druh vstupní cenu', true, false)]
    property VstupniCena: integer read FVstupniCena write FVstupniCena;

    [MVCListOf(TKooperacniObjednavkaPolozka)]
    property Polozky: TObjectList<TKooperacniObjednavkaPolozka> read FPolozkyKoopObj write SetPolozkyKoopObj;
  end;





  [MVCNameCase(ncLowerCase)]
  TVyrobniDokumentace = class(THeliosObjekty)
   private
    FID1: integer;
    FVerze: integer;
    FArchiv: boolean;
    FZdroj: integer;
    FZmenaOd: NullableInt32;
    FZmenaDo: NullableInt32;
    FIndexZmeny: string;
    FPopis: string;
    FOperace: NullableString;
    FOperaceTrim: NullableString;
    FJmenoSouboru: string;
    FDokument: NullableString;
    FTypDokumentu: NullableString;
    FPoznamka: NullableString;
    FDatPorizeni: TDateTime;
    FAutor: string;
    FDatZmeny: NullableTDateTime;
    FZmenil: NullableString;
    procedure SetOperace(const Value: NullableString);
   public
    [MVCColumn('ID1')]
    [MVCSwagJsonSchemaField(stInteger, 'ID1', 'ID1', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property ID1: integer read FID1 write FID1 default 0;

    [MVCColumn('Verze')]
    [MVCSwagJsonSchemaField(stInteger, 'Verze', 'Verze', true, false)]
    property Verze: integer read FVerze write FVerze;

    [MVCColumn('Archiv')]
    [MVCSwagJsonSchemaField(stBoolean, 'Archiv', 'Archivní záznam', true, false)]
    property Archiv: boolean read FArchiv write FArchiv default false;

    [MVCColumn('Zdroj')]
    [MVCSwagJsonSchemaField(stInteger, 'Zdroj', 'Zdroj (1=standardní TPV, 2=zakázková modifikace, 3=výrobní příkaz)', true, false)]
    property Zdroj: integer read FZdroj write FZdroj;

    [MVCColumn('ZmenaOd')]
    [MVCSwagJsonSchemaField(stInteger, 'ZmenaOd', 'ID čísleníku změn', true, false)]
    property ZmenaOd: NullableInt32 read FZmenaOd write FZmenaOd;

    [MVCColumn('ZmenaDo')]
    [MVCSwagJsonSchemaField(stInteger, 'ZmenaDo', 'ID čísleníku změn', true, false)]
    property ZmenaDo: NullableInt32 read FZmenaDo write FZmenaDo;

    [MVCColumn('IndexZmeny')]
    [MVCSwagJsonSchemaField(stString, 'IndexZmeny', 'Index změny', true, false, 0, 30)]
    property IndexZmeny: string read FIndexZmeny write FIndexZmeny;

    [MVCColumn('Operace')]
    [MVCSwagJsonSchemaField(stString, 'Operace', 'Operace', false, true, 0, 4)]
    property Operace: NullableString read FOperace write SetOperace;

    [MVCColumn('OperaceTrim')]
    property OperaceTrim: NullableString read FOperaceTrim;

    [MVCColumn('Popis')]
    [MVCSwagJsonSchemaField(stString, 'Popis', 'Popis', true, false, 0, 200)]
    property Popis: string read FPopis write FPopis;

    [MVCColumn('JmenoSouboru')]
    [MVCSwagJsonSchemaField(stString, 'JmenoSouboru', 'Jméno souboru', true, false, 0, 255)]
    property JmenoSouboru: string read FJmenoSouboru write FJmenoSouboru;

    [MVCColumn('Dokument')]
    [MVCSwagJsonSchemaField(stString, 'Dokument', 'Obsah (dokumentu)', false, true)]
    property Dokument: NullableString read FDokument write FDokument;

    [MVCColumn('TypDokumentu')]
    [MVCSwagJsonSchemaField(stString, 'TypDokumentu', 'Typ dokumentu (přípona souboru)', false, true, 0, 20)]
    property TypDokumentu: NullableString read FTypDokumentu write FTypDokumentu;

    [MVCColumn('Poznamka')]
    [MVCSwagJsonSchemaField(stString, 'Poznamka', 'Poznámka', false, true)]
    property Poznamka: NullableString read FPoznamka write FPoznamka;
   end;



implementation

uses
  System.SysUtils, System.RegularExpressions;






{ TEvidRozpracOperaceOperace }

 constructor TEvidRozpracOperaceOperace.Create;
  begin
   inherited;
   FOdvadeci:= false;
   FOperace:= '';
{$IFDEF CUSTOM_CTRL_INCOSystems}
   FMamNeuzavrenePredchozi:= false;
{$ENDIF}
  end;


 procedure TEvidRozpracOperaceOperace.OnAfterLoad;
  begin
   FJeSdruzenaOper:= FIDSdruzVyrOperaceR.IsNull;
  end;





{ TEvidRozpracOperace }

 constructor TEvidRozpracOperace.Create;
  begin
   inherited;
   FOperace:= TObjectList<TEvidRozpracOperaceOperace>.Create;
  end;


 destructor TEvidRozpracOperace.Destroy;
  begin
   inherited;
  end;


 procedure TEvidRozpracOperace.OnAfterLoad;
  begin

   if not(FDatumUzavreni.IsNull) then
     FStav:= -10
    else
     if not(FCasUkonceni.IsNull) and (FCasUkonceni.Value<Now) then
       FStav.SetNull
      else
       if not(FIDEvidRozpracOperProstoje.IsNull) then
         FStav:= -2
        else
         if not(FCasZahajeni.IsNull) and (FCasZahajeni.Value<Now) then
           FStav:= 0
          else
           FStav:= 3;


   if (FCelkovyCas.IsNull) then
     begin
      FCelkovyCas_S:= 0;
      FCelkovyCas_N:= 0;
      FCelkovyCas_H:= 0;
     end
    else
     begin
      case FCelkovyCas_T of
       0: begin
           FCelkovyCas_S:= FCelkovyCas;
           FCelkovyCas_N:= FCelkovyCas.Value * 60.0;
           FCelkovyCas_H:= FCelkovyCas.Value * 3600.0;
          end;
       1: begin
           FCelkovyCas_S:= FCelkovyCas.Value / 60.0;
           FCelkovyCas_N:= FCelkovyCas;
           FCelkovyCas_H:= FCelkovyCas.Value * 60.0;
          end;
       2: begin
           FCelkovyCas_S:= FCelkovyCas.Value / 3600.0;
           FCelkovyCas_N:= FCelkovyCas.Value / 60.0;
           FCelkovyCas_H:= FCelkovyCas;
          end;
      end;
     end;
  end;


 procedure TEvidRozpracOperace.SetOperace (const Value: System.Generics.Collections.TObjectList<TEvidRozpracOperaceOperace>);
  begin
   if (Value<>FOperace) then
    begin
     FOperace.Free;
     FOperace:= Value;
    end;
  end;





{ TVyrCisPrikaz }
 constructor TVyrCisPrikaz.Create;
  begin
   inherited;
   FMnozstvi:= 0;
   FZmetky:= 0;
   FOdvedeno:= 0;
  end;


 destructor TVyrCisPrikaz.Destroy;
  begin
   inherited;
  end;


 procedure TVyrCisPrikaz.OnAfterLoad;
  begin
  end;





{ TVyrobniPrikaz }

 procedure TVyrobniPrikaz.SetVyrobniOperace (const Value: System.Generics.Collections.TObjectList<TVyrobniOperace>);
  begin
   if (Value<>FVyrobniOperace) then
    begin
     FVyrobniOperace.Free;
     FVyrobniOperace:= Value;
    end;
  end;


 procedure TVyrobniPrikaz.SetMaterialPrikazu (const Value: System.Generics.Collections.TObjectList<TMaterialPrikazu>);
  begin
   if (Value<>FMaterial) then
    begin
     FMaterial.Free;
     FMaterial:= Value;
    end;
  end;

 procedure TVyrobniPrikaz.SetVyrCisPrikazu (const Value: System.Generics.Collections.TObjectList<TVyrCisPrikaz>);
  begin
   if (Value<>FVyrobniCisla) then
    begin
     FVyrobniCisla.Free;
     FVyrobniCisla:= Value;
    end;
  end;

 procedure TVyrobniPrikaz.SetNadrizenePrikazy (const Value: System.Generics.Collections.TObjectList<TVyrobaNadrizenePrikazy>);
  begin
   if (Value<>FNadrizenePrikazy) then
    begin
     FNadrizenePrikazy.Free;
     FNadrizenePrikazy:= Value;
    end;
  end;

 procedure TVyrobniPrikaz.SetPodrizenePrikazy (const Value: System.Generics.Collections.TObjectList<TVyrobaNadrizenePrikazy>);
  begin
   if (Value<>FPodrizenePrikazy) then
    begin
     FPodrizenePrikazy.Free;
     FPodrizenePrikazy:= Value;
    end;
  end;

 constructor TVyrobniPrikaz.Create;
  begin
   inherited;
   FVyrobniOperace:= TObjectList<TVyrobniOperace>.Create;
   FMaterial:= TObjectList<TMaterialPrikazu>.Create;
   FVyrobniCisla:= TObjectList<TVyrCisPrikaz>.Create;
   FNadrizenePrikazy:= TObjectList<TVyrobaNadrizenePrikazy>.Create;
   FPodrizenePrikazy:= TObjectList<TVyrobaNadrizenePrikazy>.Create;
  end;


 destructor TVyrobniPrikaz.Destroy;
  begin
   if (FNadrizenePrikazy<>nil) then
    FreeAndNil (FNadrizenePrikazy);
   if (FPodrizenePrikazy<>nil) then
    FreeAndNil (FPodrizenePrikazy);

   inherited;
  end;


{
 procedure TVyrobniPrikaz.NastavString(const Index: Integer; const Value: string);
  begin
   case Index of
    1: FRada:= Value;
   end;
  end;

 procedure TVyrobniPrikaz.NastavInt(const Index: Integer; const Value: integer);
  begin
   case Index of
    1: FCislo:= Value;
    2: FIDPrikazVyssi:= Value;
    3: FIDPrikazRidici:= Value;
    4: FIDTabKmen:= Value;
    5: FIDZakazka:= Value;
   end;
  end;

 procedure TVyrobniPrikaz.NastavSingle(const Index: integer; const Value: Single);
  begin
   case Index of
    1: FKsZadane:= Value;
    2: FKsCiste:= Value;
    3: FKsZive:= Value;
   end;
  end;

 procedure TVyrobniPrikaz.NastavByte(const Index: integer; const Value: Byte);
  begin
   case Index of
    1: FStavPrikazu:= Value;
   end;
  end;
}









{ TMaterialPrikazu }
 constructor TMaterialPrikazu.Create;
  begin
   inherited;
   Pozice:= '';
   FixniMnozstvi:= 0;
   FMnozstvi:= 1;
   FProcZtrat:= 0;
   FmnozstviSeZtratou:= 1;
   FMnozstviZadane:= 1;
   FPrirez:= 1;
   FMnoz_nepotrebne:= 0;
   FMnoz_skut_realizovane:= 0;
   FMnoz_odv:= 0;
   FRefMnoz:= 0;
   FVydanoRefMnoz:= 0;
   FOperace:= '    ';
  end;




 function TMaterialPrikazu.ReadPropSingle (index: TMaterialPrikazu_Cols): Extended;
  begin
   case index of
    clMnozNevydane:
      begin
       if ((FVydanoRefMnoz-FRefMnoz)>-0.0001) then
         result:= 0
        else
         result:= FMnozstviZadane - FVydanoRefMnoz * FMnozstviZadane / FRefMnoz;
      end;
   end;
  end;




 procedure TMaterialPrikazu.WritePropReadOnlySingle (index: TMaterialPrikazu_Cols; Value: Extended);
  begin
   case index of
     clMnozstviOdvedene: FMnoz_odv:= FMnoz_odv;
     clMnozNevydane:     FMnozstviNevydane:= FMnozstviNevydane;
   end;
  end;








{ TVyrobniOperace }

 procedure TVyrobniOperace.OnAfterLoad;
  begin
   Self.FinfoKusy_zad:= Self.FKusy_zad;
   Self.FKusy_zive:= 0;

   Self.FKusy_zad:= 0;
   Self.FKusy_odv:= 0;
   Self.FKusy_zmet:= 0;
   Self.FKusy_zmet_oprIO:= 0;
   Self.FKusy_zmet_neopr:= 0;
  end;


 procedure TVyrobniOperace.OnAfterInsert;
  begin
   Self.FinfoKusy_zad:= Self.FKusy_zad;
   Self.FKusy_zive:= 0;
  end;


 {
 procedure TVyrobniOperace.NastavString(const Index: Integer; const Value: string);
  begin
   case Index of
    1: FOperace:= Value;
    2: FNazev:= Value;
   end;
  end;


 procedure TVyrobniOperace.NastavInt(const Index: Integer; const Value: integer);
  begin
   case Index of
    1: FIDPrikaz:= Value;
   end;
  end;

 procedure TVyrobniOperace.NastavSingle(const Index: integer; const Value: Single);
  begin
   case Index of
    1: FKusy_zad:= Value;
   end;
  end;

 procedure TVyrobniOperace.NastavByte(const Index: integer; const Value: Byte);
  begin
   case Index of
    1: FTyp:= Value;
   end;
  end;
}







{ TKooperacniObjednavka }
 procedure TKooperacniObjednavka.SetPolozkyKoopObj(const Value: System.Generics.Collections.TObjectList<TKooperacniObjednavkaPolozka>);
  begin
   if (Value<>FPolozkyKoopObj) then
    begin
     FPolozkyKoopObj.Free;
     FPolozkyKoopObj:= Value;
    end;
  end;



 constructor TKooperacniObjednavka.Create;
  begin
   inherited;
   FCenaPolozek:= 0;
   FCenaPolozekHM:= 0;
   FCenaPrepravy:= 0;
   FCenaPrepravyHM:= 0;
   FKurz:= 1;
   FJednotkaMeny:= 1;
   FVstupniCena:= 6;
   FRealizovano:= false;
   FPolozkyKoopObj:= TObjectList<TKooperacniObjednavkaPolozka>.Create;
  end;



 destructor TKooperacniObjednavka.Destroy;
  begin
   inherited;
  end;







{ TKooperacniObjednavkaPolozka }
 constructor TKooperacniObjednavkaPolozka.Create;
  begin
   inherited;
   FKoopMnozstvi:= 0;
   FDavkaTPV:= 1;
   FKoopMnozstvi:= 0;
   FKusy:= 0;
   FKusyPrevedene:= 0;
   FCena:= 0;
   FPocetPrepravDavek:= 0;
  end;




{ TVyrobniDokumentace }
 procedure TVyrobniDokumentace.SetOperace(const Value: NullableString);
  begin
   Self.FOperace:= Value;
   Self.FOperaceTrim:= Trim(Self.FOperace);
  end;





{ TTPVCiselnikZmen }
 procedure TTPVCiselnikZmen.SetPlatnostTPV(const Value: Boolean);
  begin
   Self.FPlatnost:= Value;
   Self.FPlatnostTPV:= Value;
  end;


 procedure TTPVCiselnikZmen.SetLogins(const Value: NullableString);
  begin
   Self.FLogins:= Trim(Value);
   Self.FBlokDP:= (Self.FLogins='');
  end;





{ TTPVPrednastaveniOperaci }
 constructor TTPVPrednastaveniOperaci.Create;
  begin
   inherited;
   FKoopMnozstvi:= 0;
   FNasobekTAC:= 1;
   FPocetLidi:= 1;
   FPocetKusu:= 1;
   FPocetStroju:= 1;

   FTBC:= 0;
   FTBC_T:= 1;

   FTBC_Obsluhy:= 0;
   FTBC_Obsluhy_T:= 1;

   FTEC:= 0;
   FTEC_T:= 1;
   FTEC_S:= 0;
   FTEC_N:= 0;
   FTEC_H:= 0;

   FTAC_J:= 0;
   FTAC_J_T:= 1;
   FTAC_J_S:= 0;
   FTAC_J_N:= 0;
   FTAC_J_H:= 0;

   FTAC_KC_J:= 0;

   FMeziOperCas:= 0;
   FMeziOperCas_T:= 1;

  end;







{ TTPVOperaceDilce }

 constructor TTPVOperaceDilce.Create;
  begin
   FTyp:= 1;
  end;




{ TVyrobaNadrizenePrikazy }
 constructor TVyrobaNadrizenePrikazy.Create;
  begin
   FKryteMnozstvi:= 0;
  end;


end.
