unit uHeoObj_Base;

interface
{$I 'GlobalDefs.inc'}

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


const
{$I globalConsts.inc}

type
  THeliosObjekty = class
   private
    procedure SetID (const Value: Integer);
   protected
    [MVCTableField('ID',[foPrimaryKey])]
    FID: Integer;
    FExtInfo: NullableString; // externi informace v JSON formatu

    FAutor: string;
    FDatPorizeni: TDateTime;
    FZmenil: NullableString;
    FDatZmeny: NullableTDateTime;

    FAVAReferenceID: NullableString;
    FAVAExternalID: NullableString;

    // load events
    /// <summary>
    /// Called just after load the object state from database
    /// </summary>
    procedure OnAfterLoad; virtual;
    /// <summary>
    /// Called before load the object state from database
    /// </summary>
    procedure OnBeforeLoad; virtual;
    /// <summary>
    /// Called before insert the object state to database
    /// </summary>
    procedure OnBeforeInsert; virtual;
    /// <summary>
    /// Called after insert the object state to database
    /// </summary>
    procedure OnAfterInsert; virtual;
    /// <summary>
    /// Called before update the object state to database
    /// </summary>
    procedure OnBeforeUpdate; virtual;
    /// <summary>
    /// Called after update the object state to database
    /// </summary>
    procedure OnAfterUpdate; virtual;
    /// <summary>
    /// Called before delete object from database
    /// </summary>
    procedure OnBeforeDelete; virtual;
    /// <summary>
    /// Called after delete object from database
    /// </summary>
    procedure OnAfterDelete; virtual;
    /// <summary>
    /// Called before insert or update the object to the database
    /// </summary>
    procedure OnBeforeInsertOrUpdate; virtual;
    /// <summary>
    /// Called before execute sql
    /// </summary>
    procedure OnBeforeExecuteSQL(var SQL: string); virtual;
    /// <summary>
    /// Called after insert or update the object to the database
    /// </summary>
    procedure OnAfterInsertOrUpdate; virtual;
   public
    constructor Create; virtual;
    procedure CheckInsert; virtual;
    procedure CheckUpdate; virtual;
    procedure CheckDelete; virtual;

    [MVCColumn('ID', true)]
    [MVCSwagJsonSchemaField(stInteger, 'ID', 'ID z�znamu', true, false)]
    property ID: Integer read FID write SetID;

    [MVCColumn('ExtInfo')]
    [MVCSwagJsonSchemaField(stString, 'ExtInfo', 'Extern� informace z�znamu (JSON)', false, true)]
    property ExtInfo: NullableString read FExtInfo write FExtInfo;

    [MVCColumn('Autor')]
    [MVCSwagJsonSchemaField(stString, 'Autor', 'Autor dokladu', true, false, 1, 128)]
    property Autor: string read FAutor write FAutor;

    [MVCColumn('DatPorizeni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatPorizeni', 'Datum po��zen�', true, false)]
    property DatPorizeni: TDatetime read FDatPorizeni write FDatPorizeni;

    [MVCColumn('Zmenil')]
    [MVCSwagJsonSchemaField(stString, 'Zmenil', 'Kdo zm�nil dokument', false, true, 1, 128)]
    property Zmenil: NullableString read FZmenil write FZmenil;

    [MVCColumn('DatZmeny')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatZmeny', 'Datum zm�ny', false, true)]
    property DatZmeny: NullableTDateTime read FDatZmeny write FDatZmeny;

    [MVCColumn('AVAReferenceID')]
    [MVCSwagJsonSchemaField(stString, 'AVAReferenceID', 'AVA reference', false, true, 1, 40)]
    property AVAReferenceID: NullableString read FAVAReferenceID write FAVAReferenceID;

    [MVCColumn('AVAExternalID')]
    [MVCSwagJsonSchemaField(stString, 'AVAExternalID', 'AVA extern� ID', false, true, 1, 255)]
    property AVAExternalID: NullableString read FAVAExternalID write FAVAExternalID;
  end;

{ mustr
  [MVCNameCase(ncLowerCase)]
  TObjekt = class(THeliosObjekty)
   private
    FCislo: integer;
    procedure NastavCislo(const Value: integer);
   public
    procedure CheckInsert; override;
    procedure CheckUpdate; override;
    procedure CheckDelete; override;
    [MVCColumn('Cislo')]
    property Cislo: integer read FCislo write NastavCislo;
  end;
}


  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPlanKalendPol')]
  TPolozkaPlanKal = class(THeliosObjekty)
   private
//    [MVCTableField('ID',[foPrimaryKey])]
//    FID: integer;
    FIDKalendar: NullableInt32;
    FIDStroj: NullableInt32;
    FIDKooperace: NullableInt32;
    FIDVyrPerZdroj: NullableInt32;
    FDatum: TDateTime;
    FKoefPlneni: Extended;
    FMinOd: NullableInt32;
    FMinDo: NullableInt32;
    FIDSmeny: NullableInt32;
   public
    [MVCColumn('IDPlanKalend')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKalendar', 'ID pl�novac�ho kalend��e', false, true)] // required, nullable
    property IDKalendar: NullableInt32 read FIDKalendar write FIDKalendar;

    [MVCColumn('IDStroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStroj', 'ID stroje', false, true)] // required, nullable
    property IDStroj: NullableInt32 read FIDStroj write FIDStroj;

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

    [MVCColumn('IDVyrPerZdroje')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVyrPerZdroje', 'ID person�ln�ho zdroje', false, true)] // required, nullable
    property IDVyrPerZdroj: NullableInt32 read FIDVyrPerZdroj write FIDVyrPerZdroj;

    [MVCColumn('IDSmeny')]
    [MVCSwagJsonSchemaField(stInteger, 'IDSmeny', 'ID sm�ny', false, true)] // required, nullable
    property IDSmeny: NullableInt32 read FIDSmeny write FIDSmeny;

    [MVCColumn('Datum')]
    [MVCSwagJsonSchemaField(stDate, 'Datum', 'Datum pl�novac�ho kalend��e', true, false)] // required, nullable
    property Datum: TDateTime read FDatum write FDatum;

    [MVCColumn('KoefPlneni')]
    [MVCSwagJsonSchemaField(stNumber, 'KoefPlneni', 'Koeficient pln�n�', true, false)] // required, nullable
    property KoefPlneni: Extended read FKoefPlneni write FKoefPlneni;

    [MVCColumn('MinOd')]
    [MVCSwagJsonSchemaField(stInteger, 'MinOd', 'Minuty (od)', false, true)] // required, nullable
    property MinOd: NullableInt32 read FMinOd write FMinOd;

    [MVCColumn('MinDo')]
    [MVCSwagJsonSchemaField(stInteger, 'MinDo', 'Minuty (do)', false, true)] // required, nullable
    property MinDo: NullableInt32 read FMinDo write FMinDo;
  end;



  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPlanKalendare')]
  TPlanKalendar = class(THeliosObjekty)
   private
//    [MVCTableField('ID',[foPrimaryKey])]
//    FID: integer;
    FVychozi: boolean;
    FUplatnitSvatky: boolean;
    FOznaceni: string;
    FNazev: NullableString;
    FPocetTydnuPredpisu: integer;
    FPolozky: TObjectList<TPolozkaPlanKal>;
    procedure SetPolozkyKalendare (const Value: TObjectList<TPolozkaPlanKal>);
   public
    constructor Create; virtual;
    destructor Destroy; override;

    [MVCColumn('Vychozi')]
    [MVCSwagJsonSchemaField(stBoolean, 'Vychozi', 'V�choz� kalend��', true, false)] // required, nullable
    property Vychozi: boolean read FVychozi write FVychozi;

    [MVCColumn('UplatnitSvatky')]
    [MVCSwagJsonSchemaField(stBoolean, 'UplatnitSvatky', 'Uplatnit sv�tky', true, false)] // required, nullable
    property UplatnitSvatky: boolean read FUplatnitSvatky write FUplatnitSvatky;

    [MVCColumn('Oznaceni')]
    [MVCSwagJsonSchemaField(stString, 'Oznaceni', 'Ozna�en� pl�novac�ho kalend��e', true, false, 1, 10)] // required, nullable
    property Oznaceni: string read FOznaceni write FOznaceni;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'N�zev pl�novac�ho kalend��e', false, true, 1, 100)] // required, nullable
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('PocetTydnuPredpisu')]
    [MVCSwagJsonSchemaField(stInteger, 'PocetTydnuPredpisu', 'Po�et t�dn� p�edpisu', true, false)] // required, nullable
    property PocetTydnuPredpisu: integer read FPocetTydnuPredpisu write FPocetTydnuPredpisu;

    [MVCListOf(TPolozkaPlanKal)]
    property Polozky: TObjectList<TPolozkaPlanKal> read FPolozky write SetPolozkyKalendare;
  end;




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabDokumentStrom')]
  TDokumentStrom = class(THeliosObjekty)
   private
    FIDParent: NullableInt32;
    FNazevUrovne: string;
    FFullNazev: string;
    FPoradiVeVetvi: Integer;
   public
    [MVCColumn('IDParent')]
    [MVCSwagJsonSchemaField(stInteger, 'IDParent', 'ID rodi�ovsk� �rovn�', false, true)]
    property IDParent: NullableInt32 read FIDParent write FIDParent;

    [MVCColumn('NazevUrovne')]
    [MVCSwagJsonSchemaField(stString, 'NazevUrovne', 'N�zev �rovn�', true, false, 0, 255)] // required, nullable
    property NazevUrovne: string read FNazevUrovne write FNazevUrovne;

    [MVCColumn('FullNazev')]
    [MVCSwagJsonSchemaField(stString, 'FullNazev', 'Pln� n�zev �rovn�', true, false, 0, 255)] // required, nullable
    property FullNazev: string read FFullNazev write FFullNazev;

    [MVCColumn('PoradiVeVetvi')]
    [MVCSwagJsonSchemaField(stInteger, 'PoradiVeVetvi', 'Po�ad� ve v�tvi', true, false)]
    property PoradiVeVetvi: integer read FPoradiVeVetvi write FPoradiVeVetvi;
   end;




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabDokument')]
  TDokument = class(THeliosObjekty)
   private
    FPopis: string;
    FJmenoACesta: string;
    FDokument: NullableString;
    FUlozenoDB: Boolean;
    FVelikostVDB: integer;
    FSledovatHistorii: Boolean;
    FIDDokumStrom: NullableInt32;
    FIDDokTyp: NullableInt32;
    FDatPorizeni: TDateTime;
    FDatZmeny: NullableTDateTime;
    FAutor, FZmenil: string;
   public
    [MVCColumn('Popis')]
    [MVCSwagJsonSchemaField(stString, 'Popis', 'Popis dokumentu', true, false, 1, 255)] // required, nullable
    property Popis: string read FPopis write FPopis;

    [MVCColumn('JmenoACesta')]
    [MVCSwagJsonSchemaField(stString, 'JmenoACesta', 'Jm�no a cesta k ulo�en�mu dokumentu', true, false, 1, 255)]
    property JmenoACesta: string read FJmenoACesta write FJmenoACesta;

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

    [MVCColumn('UlozenoDB')]
    [MVCSwagJsonSchemaField(stBoolean, 'UlozenoDB', 'Dokument je ulo�en v datab�zi', true, false)]
    property UlozenoDB: Boolean read FUlozenoDB write FUlozenoDB;

    [MVCColumn('VelikostVDB')]
    [MVCSwagJsonSchemaField(stInteger, 'VelikostVDB', 'Velikost souboru', true, false)]
    property VelikostVDB: integer read FVelikostVDB write FVelikostVDB;

    [MVCColumn('SledovatHistorii')]
    [MVCSwagJsonSchemaField(stBoolean, 'SledovatHistorii', 'Sledovat historii dokumentu', true, false)]
    property SledovatHistorii: Boolean read FSledovatHistorii write FSledovatHistorii;

    [MVCColumn('IDDokumStrom')]
    [MVCSwagJsonSchemaField(stInteger, 'IDDokumStrom', 'ID stromov� struktury dokumentu', false, true)]
    property IDDokumStrom: NullableInt32 read FIDDokumStrom write FIDDokumStrom;

    [MVCColumn('IDDokTyp')]
    [MVCSwagJsonSchemaField(stInteger, 'IDDokTyp', 'ID typu dokumentu', false, true)]
    property IDDokTyp: NullableInt32 read FIDDokTyp write FIDDokTyp;
  end;




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TSerioveCisloStav')]
  TSerioveCisloStav = class(THeliosObjekty)
   private
    FIDStavSkladu: integer;
    FIDVyrCK: integer;
    FNazev1, FNazev2: string;
    FMnozstvi, FMnozstviDispo: Extended;
    FDatPorizeni: TDateTime;
    FDatVstup, FDatExpirace: NullableTDatetime;
   public
    [MVCColumn('IDStavSkladu')]
    [MVCSwagJsonSchemaField('IDStavSkladu', 'ID karty stavu skladu', true, false)]
    property IDStavSkladu: integer read FIDStavSkladu write FIDStavSkladu;

    [MVCColumn('Nazev1')]
{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCSwagJsonSchemaField(stString, 'Nazev1', 'Číslo paletového listu (výrobní číslo)', true, false, 1, 100)]
{$ELSE}
    [MVCSwagJsonSchemaField('Nazev1', 'Výrobní číslo', true, false, 1, 100)]
{$ENDIF}
    property Nazev1: string read FNazev1 write FNazev2;

    [MVCColumn('Nazev2')]
{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCSwagJsonSchemaField(stString, 'Nazev2', 'Šarže (popis výrobního číslo)', true, false, 1, 100)]
{$ELSE}
    [MVCSwagJsonSchemaField('Nazev2', 'Popis výrobního číslo', true, false, 1, 100)]
{$ENDIF}
    property Nazev2: string read FNazev2 write FNazev2;

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

    [MVCColumn('MnozstviDispo')]
    [MVCSwagJsonSchemaField('MnozstviDispo', 'Množství k dispozici', true, false)]
    property MnozstviDispo: Extended read FMnozstviDispo write FMnozstviDispo;

    [MVCColumn('DatPorizeni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatPorizeni', 'Datum pořízení', true, false)]
    property DatPorizeni: TDatetime read FDatPorizeni write FDatPorizeni;

    [MVCColumn('DatVstup')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatVstup', 'Datum vstup', false, true)]
    property DatVstup: NullableTDatetime read FDatVstup write FDatVstup;

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




  [MVCNameCase(ncLowerCase)]
  [MVCTable('TSerioveCisloPohybOZ')]
  TSerioveCisloPohybOZ = class(THeliosObjekty)
   private
    FIDPolozkaOZ: integer;
    FIDVyrCS: integer;
    FIDVyrCK: integer;
    FNazev: NullableString;
    FVyrCis: NullableString;
    FMnozstvi: Extended;
    FMnozstviEvid: Extended;
    FDatVstup: NullableTDateTime;
    FDatVystup: NullableTDateTime;
    FDatExpirace: NullableTDateTime;
    FPoznamka: NullableString;
    FZdrojSD: NullableString;
    FIDDokladGSD: NullableInt32;
   public
    [MVCColumn('IDPolozkaDokladu')] // 2nd param=true if is PrimaryKey
    [MVCSwagJsonSchemaField(stInteger, 'IDPolozkaDokladu', 'ID pohybu zboží dokladu OZ', true, false)]
    property IDPolozkaDokladu: integer read FIDPolozkaOZ write FIDPolozkaOZ;

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

    [MVCColumn('MnozstviEvid')]
    [MVCSwagJsonSchemaField(stNumber, 'MnozstviEvid', 'Množství v evidenční jednotce', true, false)]
    property MnozstviEvid: Extended read FMnozstviEvid write FMnozstviEvid;

    [MVCColumn('IDVyrCis')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVyrCis', 'ID karty stavu skladu', true, false)]
    property IDVyrCis: integer read FIDVyrCS write FIDVyrCS;

    [MVCColumn('Nazev')] // nazev ze Selectu
{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCSwagJsonSchemaField(stString, 'Nazev1', 'Šarže (popis výrobního číslo)', true, false, 1, 100)]
{$ELSE}
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Popis výrobního čísla', true, false, 1, 100)]
{$ENDIF}
    property Nazev: NullableString read FNazev write FNazev;

    [MVCColumn('VyrCis')]
{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCSwagJsonSchemaField(stString, 'VyrCis', 'Číslo paletového listu (výrobní číslo)', true, false, 1, 100)]
{$ELSE}
    [MVCSwagJsonSchemaField(stString, 'VyrCis', 'Výrobní číslo', true, false, 1, 100)]
{$ENDIF}
    property VyrCis: NullableString read FVyrCis write FVyrCis;

    [MVCColumn('DatVstup')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatVstup', 'Datum vstupu', false, true)]
    property DatVstup: NullableTDateTime read FDatVstup write FDatVstup;

    [MVCColumn('DatVystup')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatVystup', 'Datum výstupu', false, true)]
    property DatVystup: NullableTDateTime read FDatVystup write FDatVystup;

    [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)]
    property Poznamka: NullableString read FPoznamka write FPoznamka;

    [MVCColumn('ZdrojSD')]
    [MVCSwagJsonSchemaField(stString, 'ZdrojSD', '1=zdrojem dat je SD ScanData', false, true)]
    property ZdrojSD: NullableString read FZdrojSD write FZdrojSD;

    [MVCColumn('IDDokladGSD')]
    [MVCSwagJsonSchemaField(stInteger, 'IDDokladGSD', 'Id dokladu SD serveru', false, true)]
    property IDDokladGSD: NullableInt32 read FIDDokladGSD write FIDDokladGSD;

  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabUmisteni')]
  TUmisteni = class(THeliosObjekty)
   private
    FIDSklad: string;
    FKod: string;
    FNazev: string;
    FPoznamka: NullableString;
    FBlokovano: Boolean;
   public
    constructor Create; virtual;
    destructor Destroy; override;

    [MVCColumn('IDSklad')]
    [MVCSwagJsonSchemaField(stString, 'IDSklad', 'Sklad umístění', true, false, 1, 30)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDSklad: string read FIDSklad write FIDSklad;

    [MVCColumn('Kod')]
    [MVCSwagJsonSchemaField(stString, 'Kod', 'Kód umístení', true, false, 1, 15)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Kod: string read FKod write FKod;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField(stString, 'Nazev', 'Název umístení', true, false, 1, 40)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Nazev: string read FNazev write FNazev;

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

    [MVCColumn('Blokovano')]
    [MVCSwagJsonSchemaField(stBoolean, 'Blokovano', 'Blokováno', true, false)]
    property Blokovano: Boolean read FBlokovano write FBlokovano default false;
   end;






  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabPohybyZbozi')]
  TPohybOZ = class(THeliosObjekty)
   private
//    FID: integer;
    FIDDoklad: integer;
    FJednotkaMeny: integer;
    FVstupniCena: integer;
    FPoradi: integer;
    FDruhPohybu: integer;
    FSkupZbo: string;
    FRegCis: string;
    FIDKmenZbozi: integer;
    FIDZboSklad: integer;
    FNazev1, FNazev2, FNazev3, FNazev4, FNazSoz1, FNazSoz2, FNazSoz3, FNazSoz4: string;
    FMena, FMJ, FMJEvidence: NullableString;
    FMnozstvi: Extended;
    FKurz: Extended;
    FIDOldPolozka: NullableInt32;
    FIDOldDoklad: NullableInt32;
    FIDPrikaz: NullableInt32;
    FTypVyrobnihoDokladu: NullableInt32;
    FUmisteni: TUmisteni;
    FSerialNums: TObjectList<TSerioveCisloPohybOZ>;
{$IFDEF CUSTOM_CTRL_Rootvin}
    FPHObjIdent: NullableInt32;
    FPHPolIdent: NullableInt32;
    FSilo: NullableInt32;
    FSarze: NullableString;
    FPaletList: NullableString;
    FIDMzdy: NullableInt32;
{$ENDIF}
    procedure ZapisIDKmene;
    procedure SetSerialNums( const Value: TObjectList<TSerioveCisloPohybOZ>);
    procedure SetUmisteni (const Value: TUmisteni);
   public
    constructor Create; virtual;
    destructor Destroy; override;

//    [MVCColumn('IDTabStrom')] // nazev v tabulce
//    [MVCTableField('Stredisko')] // nazev pro API

    [MVCColumn('IDDoklad')] // 2nd param=true if is PrimaryKey
    [MVCSwagJsonSchemaField(stInteger, 'IDDoklad', 'ID dokladu', true, false)]  // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDDoklad: integer read FIDDoklad write FIDDoklad;

    [MVCColumn('Poradi')]
    [MVCSwagJsonSchemaField(stInteger, 'Poradi', 'Poradi polozky na dokladu', true, false)]
    property Poradi: integer read FPoradi write FPoradi;

    [MVCColumn('DruhPohybuZbo')]
    [MVCTableField('DruhPohybu')]
    [MVCSwagJsonSchemaField(stInteger, 'DruhPohybu', 'Druh pohybu zbozi', true, false)]
    property DruhPohybu: integer read FDruhPohybu write FDruhPohybu;

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

    [MVCColumn('SkupZbo')]
    [MVCSwagJsonSchemaField(stString, 'SkupZbo', 'Skupina karet', true, false, 1, 3)]
    property SkupZbo: string read FSkupZbo write FSkupZbo;

    [MVCColumn('RegCis')]
    [MVCSwagJsonSchemaField(stString, 'RegCis', 'Registracni cislo', true, false, 1, 30)]
    property RegCis: string read FRegCis write FRegCis;

    [MVCColumn('IDZboSklad')]
    [MVCSwagJsonSchemaField(stInteger, 'IDZboSklad', 'ID skladov0 karty', true, false)]
    property IDZboSklad: integer read FIDZboSklad write FIDZboSklad;

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

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

    [MVCColumn('Nazev2')]
    [MVCSwagJsonSchemaField(stString, 'Nazev2', 'Název 2', true, false, 1, 100)]
    property Nazev2: string read FNazev2 write FNazev2;

    [MVCColumn('Nazev3')]
    [MVCSwagJsonSchemaField(stString, 'Nazev3', 'Název 3', true, false, 1, 100)]
    property Nazev3: string read FNazev3 write FNazev3;

    [MVCColumn('Nazev4')]
    [MVCSwagJsonSchemaField(stString, 'Nazev4', 'Název 4', true, false, 1, 100)]
    property Nazev4: string read FNazev4 write FNazev4;

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

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

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

    [MVCColumn('Popis4')]
    [MVCTableField('NazevSozNa4')] // nazev pro API
    [MVCSwagJsonSchemaField(stString, 'NazevSozNa4', '', true, false, 1, 100)]
    property Popis4: string read FNazSoz4 write FNazSoz4;

    [MVCColumn('MJ')]
    [MVCSwagJsonSchemaField(stString, 'MJ', 'MJ', false, true, 1, 10)]
    property MJ: NullableString read FMJ write FMJ;

    [MVCColumn('MJEvidence')]
    [MVCSwagJsonSchemaField(stString, 'MJEvidence', 'MJEvidence', false, true, 1, 10)]
    property MJEvidence: NullableString read FMJEvidence write FMJEvidence;

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

    [MapperListOf(TSerioveCisloPohybOZ)]
    property SerialNums: TObjectList<TSerioveCisloPohybOZ> read FSerialNums write SetSerialNums;

    [MVCColumn('IDUmisteni')]
    [MapperListOf(TUmisteni)]
    property Umisteni: TUmisteni read FUmisteni write SetUmisteni;

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID zdrojov�ho v�robn�ho p��kazu', false, true)]
    property IDPrikaz: NullableInt32 read FIDPrikaz write FIDPrikaz;

    [MVCColumn('IDOldDoklad')]
    [MVCSwagJsonSchemaField(stInteger, 'IDOldDoklad', 'ID p�vodn�ho dokladu', false, true)]
    property IDOldDoklad: NullableInt32 read FIDOldDoklad write FIDOldDoklad;

    [MVCColumn('IDOldPolozka')]
    [MVCSwagJsonSchemaField(stInteger, 'IDOldPolozka', 'ID p�vodn� polo�ky', false, true)]
    property IDOldPolozka: NullableInt32 read FIDOldPolozka write FIDOldPolozka;

    [MVCColumn('TypVyrobnihoDokladu')]
    [MVCSwagJsonSchemaField(stInteger, 'TypVyrobnihoDokladu', 'Typ v�robn�ho dokladu - 0=odv�d�n� v�robku, 1=v�dej materi�lu, ', false, true)]
    property TypVyrobnihoDokladu: NullableInt32 read FTypVyrobnihoDokladu write FTypVyrobnihoDokladu;

{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCColumn('PHObjIdent')]
    [MVCSwagJsonSchemaField(stInteger, 'PHObjIdent', 'ID objednavky PH', false, true)]
    property PHObjIdent: NullableInt32 read FPHObjIdent write FPHObjIdent;

    [MVCColumn('PHPolIdent')]
    [MVCSwagJsonSchemaField(stInteger, 'PHPolIdent', 'ID radku objednavky PH', false, true)]
    property PHPolIdent: NullableInt32 read FPHPolIdent write FPHPolIdent;

    [MVCColumn('Silo')]
    [MVCSwagJsonSchemaField(stInteger, 'Silo', 'Cislo sila (u mouky)', false, true)]
    property Silo: NullableInt32 read FSilo write FSilo;

    [MVCColumn('Sarze')]
    [MVCSwagJsonSchemaField(stString, 'Sarze', '�ar�e (posledn� p�eveden� na sklad)', false, true)]
    property Sarze: NullableString read FSarze write FSarze;

    [MVCColumn('PaletList')]
    [MVCSwagJsonSchemaField(stString, 'PaletList', 'Paletov� list', false, true)]
    property PaletList: NullableString read FPaletList write FPaletList;

    [MVCColumn('IDMzdy')]
    [MVCSwagJsonSchemaField(stInteger, 'IDMzdy', 'ID evidence operace, z jake byla polozka generovana', false, true)]
    property IDMzdy: NullableInt32 read FIDMzdy write FIDMzdy;
{$ENDIF}
  end;





  [MVCTable('TabDokladyZbozi')]
  [MVCNameCase(ncLowerCase)]
  TDruhDokZbo = class(THeliosObjekty)
   private
    FRadaDokladu: string;
    FNazev: string;
    FNavaznaRada: NullableString;
    FDruhPohybu: integer;
    FUKod: NullableInt32;
    FTypPrevodky: NullableString;
    FIDSkladPrevodu: NullableString;
    FCisloOrg: NullableInt32;
    FVstupniCena: integer;
    FCisloZakazky: NullableString;
    FAutoRealizace: integer;
    FFormaUhrady: NullableString;
   public
    [MVCColumn('RadaDokladu')]
    [MVCSwagJsonSchemaField('RadaDokladu', '�ada dokladu', true, false, 0, 3)]
    property RadaDokladu: string read FRadaDokladu write FRadaDokladu;

    [MVCColumn('DruhPohybuZbo')] // nazev v tabulce
    [MVCTableField('DruhPohybu')] // nazev pro API
    [MVCSwagJsonSchemaField('DruhPohybu', 'Druh pohybu zbo��', true, false)]
    property DruhPohybu: integer read FDruhPohybu write FDruhPohybu;

    [MVCColumn('NavaznaRada')]
    [MVCSwagJsonSchemaField('NavaznaRada', 'N�vazn� �ada dokladu', false, true, 0, 3)]
    property NavaznaRada: NullableString read FNavaznaRada write FNavaznaRada;

    [MVCColumn('Nazev')]
    [MVCSwagJsonSchemaField('Nazev', 'N�zev �ady dokladu', true, false, 0, 40)]
    property Nazev: string read FNazev write FNazev;

    [MVCColumn('UKod')]
    [MVCSwagJsonSchemaField(stInteger, 'UKod', '��etn� k�d (kontace)', false, true)]
    property UKod: NullableInt32 read FUKod write FUKod;

    [MVCColumn('TypPrevodky')]
    [MVCSwagJsonSchemaField(stString, 'TypPrevodky', '�ada dokladu p�evodu', false, true, 0, 3)]
    property TypPrevodky: NullableString read FTypPrevodky write FTypPrevodky;

    [MVCColumn('IDSkladPrevodu')]
    [MVCSwagJsonSchemaField(stString, 'IDSkladPrevodu', 'Sklad p�evodu', false, true, 0, 30)]
    property IDSkladPrevodu: NullableString read FIDSkladPrevodu write FIDSkladPrevodu;

    [MVCColumn('CisloOrg')]
    [MVCSwagJsonSchemaField(stInteger, 'CisloOrg', '��slo organizace', false, true)]
    property CisloOrg: NullableInt32 read FCisloOrg write FCisloOrg;

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

    [MVCColumn('CisloZakazky')]
    [MVCSwagJsonSchemaField(stString, 'CisloZakazky', '��slo zak�zky', false, true, 0, 15)]
    property CisloZakazky: NullableString read FCisloZakazky write FCisloZakazky;

    [MVCColumn('AutoRealizace')]
    [MVCSwagJsonSchemaField(stInteger, 'AutoRealizace', 'Automatick� realizace', true, false)]
    property AutoRealizace: integer read FAutoRealizace write FAutoRealizace;

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




  [MVCTable('TabDokladyZbozi')]
  [MVCNameCase(ncLowerCase)]
  TDokladOZ = class(THeliosObjekty)
   private
    FCislo: integer;
    FRadaDokladu: string;
    FDruhPohybu: integer;
    FDruPohybuPrevod: integer;
    FIDSklad: string;
    FIDSkladPrevodu: NullableString;
    FDatPorizeni: TDatetime;
    FDatRealizace, FDatDUZP, FDatSplatnost: NullableTDatetime;
    FCisloOrg: NullableInt32;
    FVstupniCena: integer;
    FParovaciZnak: string;
    FCisloZakazky: NullableString;
    FPohybyOZ: TObjectList<TPohybOZ>;
    FKurz: Extended;
    FMena: string;
    FFormaUhrady: NullableString;
    FIDPrikaz: NullableInt32;
    procedure SetPohybyOZ(const Value: TObjectList<TPohybOZ>);
   public
    constructor Create; virtual;
    destructor Destroy; override;

//    [MVCColumn('IDTabStrom')] // nazev v tabulce
//    [MVCTableField('Stredisko')] // nazev pro API

    [MVCColumn('PoradoveCislo')] // 2nd param=true if is PrimaryKey
    [MVCSwagJsonSchemaField('Cislo', 'Po�adove ��slo dokladu', true, false)] // required, nullable, minlen, maxlen
    property PoradoveCislo: integer read FCislo write FCislo;

    [MVCColumn('RadaDokladu')]
    [MVCSwagJsonSchemaField('RadaDokladu', '�ada dokladu', true, false, 0, 3)]
    property RadaDokladu: string read FRadaDokladu write FRadaDokladu;

    [MVCColumn('DruhPohybuZbo')] // nazev v tabulce
    [MVCTableField('DruhPohybu')] // nazev pro API
    [MVCSwagJsonSchemaField('DruhPohybu', 'Druh pohybu zbo��', true, false)]
    property DruhPohybu: integer read FDruhPohybu write FDruhPohybu;

    [MVCColumn('DruhPohybuPrevod')] // nazev v tabulce
    [MVCTableField('DruhPohybuPrevod')] // nazev pro API
    [MVCSwagJsonSchemaField('DruhPohybuPrevod', 'Druh pohybu p�evodu', false, true)]
    property DruhPohybuPrevod: integer read FDruPohybuPrevod write FDruPohybuPrevod;

    [MVCColumn('IDSklad')]
    [MVCSwagJsonSchemaField(stString, 'IDSklad', 'Sklad', true, false, 0, 30)]
    property IDSklad: string read FIDSklad write FIDSklad;

    [MVCColumn('IDSkladPrevodu')]
    [MVCSwagJsonSchemaField(stString, 'IDSkladPrevodu', 'Sklad p�evodu', false, true, 0, 30)]
    property IDSkladPrevodu: NullableString read FIDSkladPrevodu write FIDSkladPrevodu;

    [MVCColumn('CisloOrg')]
    [MVCSwagJsonSchemaField(stInteger, 'CisloOrg', '��slo organizace', false, true)]
    property CisloOrg: NullableInt32 read FCisloOrg write FCisloOrg;

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

    [MVCColumn('DatRealizace')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatRealizace', 'Datum realizace', false, true)]
    property DatRealizace: NullableTDatetime read FDatRealizace write FDatRealizace;

    [MVCColumn('DUZP')]
    [MVCSwagJsonSchemaField(stDateTime, 'DUZP', 'Datum uskute�n�n� zdaniteln�ho pln�n�', false, true)]
    property DUZP: NullableTDatetime read FDatDUZP write FDatDUZP;

    [MVCColumn('Splatnost')]
    [MVCSwagJsonSchemaField(stDateTime, 'Splatnost', 'Splatnost', false, true)]
    property Splatnost: NullableTDatetime read FDatSplatnost write FDatSplatnost;

    [MVCColumn('ParovaciZnak')]
    [MVCSwagJsonSchemaField(stString, 'ParovaciZnak', 'P�rovac� znak', true, false, 0, 20)]
    property ParovaciZnak: string read FParovaciZnak write FParovaciZnak;

    [MVCColumn('CisloZakazky')]
    [MVCSwagJsonSchemaField(stString, 'CisloZakazky', '��slo zak�zky', false, true, 0, 15)]
    property CisloZakazky: NullableString read FCisloZakazky write FCisloZakazky;

//    [MapperListOf(TPohybOZ)]
    property PohybyOZ: TObjectList<TPohybOZ> read FPohybyOZ write SetPohybyOZ;

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

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

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

    [MVCColumn('IDPrikaz')]
    [MVCSwagJsonSchemaField(stInteger, 'IDPrikaz', 'ID zdrojov�ho v�robn�ho p��kazu', false, true)]
    property IDPrikaz: NullableInt32 read FIDPrikaz write FIDPrikaz;
  end;







  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabStavSkladu')]
  TStavSkladu = class(THeliosObjekty)
   private
//    FID: integer;
    FIDSklad: string;
    FIDKmenZbozi: integer;
    FMnozstvi: Extended;
    FMinimum, FMaximum: Extended;
    FObjednano: Extended;
   public
//    [MVCColumn('IDTabStrom')] // nazev v tabulce
//    [MVCTableField('Stredisko')] // nazev pro API

    [MVCColumn('IDSklad')] // 2nd param=true if is PrimaryKey
    [MVCSwagJsonSchemaField('IDSklad', 'Číslo skladu', true, false, 1, 30)]
    property IDSklad: string read FIDSklad write FIDSklad;

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

    [MVCColumn('Mnozstvi')]
    [MVCSwagJsonSchemaField('Mnozstvi', 'Mnozstvi', true, false)]
    property Mnozstvi: Extended read FMnozstvi write FMnozstvi;

    [MVCColumn('Minimum')]
    [MVCSwagJsonSchemaField('Minimum', 'Minimum', true, false)]
    property Minimum: Extended read FMinimum write FMinimum;

    [MVCColumn('Maximum')]
    [MVCSwagJsonSchemaField('Maximum', 'Maximum', true, false)]
    property Maximum: Extended read FMaximum write FMaximum;

    [MVCColumn('Objednano')]
    [MVCSwagJsonSchemaField('Objednano', 'Objednano', true, false)]
    property Objednano: Extended read FObjednano write FObjednano;
  end;






  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabUkoly')]
  TUkolAktivity = class(THeliosObjekty)
   private
    FPredmet: string;
    FTerminZahajeni: NullableTDateTime;
    FTerminSplneni: NullableTDateTime;
    FDatumZahajeni: NullableTDateTime;
    FDatumKontroly: NullableTDateTime;
    FDatumDokonceni: NullableTDateTime;
    FStav: Integer;
    FPriorita: integer;
    FHotovoProcent: Extended;
    FZadavatel: NullableInt32;
    FIDUtvarZadavatel: NullableInt32;
    FResitel: NullableInt32;
    FIDUtvarResitel: NullableInt32;
    FCelkemHod: Extended;
    FHotovoHod: Extended;
    FIDKontJednani: NullableInt32;
    FIDUkolu: NullableInt32;
    FPopis, FPopis1: NullableString;
   public
    constructor Create;
    destructor Destroy; override;

    [MVCColumn('Predmet')]
    [MVCSwagJsonSchemaField(stString, 'Predmet', 'Předmět úkolu', true, false, 0, 255)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Predmet: string read FPredmet write FPredmet;

    [MVCColumn('TerminZahajeni')]
    [MVCSwagJsonSchemaField(stDateTime, 'TerminZahajeni', 'Termín plánovaného zahájení', false, true)]
    property TerminZahajeni: NullableTDateTime read FTerminZahajeni write FTerminZahajeni;

    [MVCColumn('TerminSplneni')]
    [MVCSwagJsonSchemaField(stDateTime, 'TerminSplneni', 'Termín plánovaného splnění', false, true)]
    property TerminSplneni: NullableTDateTime read FTerminSplneni write FTerminSplneni;

    [MVCColumn('DatumZahajeni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumZahajeni', 'Datum skutečného zahájení', false, true)]
    property DatumZahajeni: NullableTDateTime read FDatumZahajeni write FDatumZahajeni;

    [MVCColumn('DatumKontroly')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumKontroly', 'Datum kontroly', false, true)]
    property DatumKontroly: NullableTDateTime read FDatumKontroly write FDatumKontroly;

    [MVCColumn('DatumDokonceni')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumDokonceni', 'Datum skutečného dokončení', false, true)]
    property DatumDokonceni: NullableTDateTime read FDatumDokonceni write FDatumDokonceni;

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

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

    [MVCColumn('HotovoProcent')]
    [MVCSwagJsonSchemaField(stNumber, 'HotovoProcent', 'Hotovo (procent)', true, false)]
    property HotovoProcent: Extended read FHotovoProcent write FHotovoProcent;

    [MVCColumn('Zadavatel')]
    [MVCSwagJsonSchemaField(stInteger, 'Zadavatel', 'Zadavatel (zaměstnanec)', false, true)]
    property Zadavatel: NullableInt32 read FZadavatel write FZadavatel;

    [MVCColumn('IDUtvarZadavatel')]
    [MVCSwagJsonSchemaField(stInteger, 'IDUtvarZadavatel', 'ID útvar Zadavatele', false, true)]
    property IDUtvarZadavatel: NullableInt32 read FIDUtvarZadavatel write FIDUtvarZadavatel;

    [MVCColumn('Resitel')]
    [MVCSwagJsonSchemaField(stInteger, 'Resitel', 'Řešitel (zaměstnanec)', false, true)]
    property Resitel: NullableInt32 read FResitel write FResitel;

    [MVCColumn('IDUtvarResitel')]
    [MVCSwagJsonSchemaField(stInteger, 'IDUtvarResitel', 'ID útvar Řešitele', false, true)]
    property IDUtvarResitel: NullableInt32 read FIDUtvarResitel write FIDUtvarResitel;

    [MVCColumn('IDKontJednani')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKontJednani', 'ID aktivity', false, true)]
    property IDKontJednani: NullableInt32 read FIDKontJednani write FIDKontJednani;

    [MVCColumn('IDUkolu')]
    [MVCSwagJsonSchemaField(stInteger, 'IDUkolu', 'ID souvisejícího úkolu', false, true)]
    property IDUkolu: NullableInt32 read FIDUkolu write FIDUkolu;

    [MVCColumn('CelkemHod')]
    [MVCSwagJsonSchemaField(stNumber, 'CelkemHod', 'Celkem hodin plán', true, false)]
    property CelkemHod: Extended read FCelkemHod write FCelkemHod;

    [MVCColumn('HotovoHod')]
    [MVCSwagJsonSchemaField(stNumber, 'HotovoHod', 'Hodin hotovo', true, false)]
    property HotovoHod: Extended read FHotovoHod write FHotovoHod;

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

    [MVCColumn('Popis1')]
    [MVCSwagJsonSchemaField(stString, 'Popis1', 'Popis1', false, true)]
    property Popis1: NullableString read FPopis1 write FPopis1;
  end;



// TabKontaktJednani
  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabAktivita')]
  TAktivita = class(THeliosObjekty)
   protected
    FPoradoveCislo: integer;
    FKategorie: string;
    FPredmet: string;
    FTyp: string;
    FStav: string;
    FDruhVystupu: string;
    FCisloOrg: NullableInt32;
    FCisloZam: NullableInt32;
    FCisloKontOsoba: NullableInt32;
    FCisloZakazky: NullableString;
    FNakladOkruh: NullableString;
    FUtvar: NullableString;
    FMistoKonani: string;
    FDatumJednOd: NullableTDateTime;
    FDatumJednDo: NullableTDateTime;
    FIDSouvisKJ: NullableInt32;
    FPopis: NullableString;
    FIDCis1: NullableInt32;
    FIDCis2: NullableInt32;
    FIDCis3: NullableInt32;
    FIDMajetek: NullableInt32;
    FIDKmenZbozi: NullableInt32;
    FIDStavSkladu: NullableInt32;
    FIDVyrCS: NullableInt32;
    FIDStroj: NullableInt32;

    FUkoly: TObjectList<TUkolAktivity>;
    procedure SetUkoly (const Value: TObjectList<TUkolAktivity>);
   public
    constructor Create;
    destructor Destroy; override;

//    [MVCTableField('ID', [foPrimaryKey])]
    [MVCColumn('PoradoveCislo')]
    [MVCSwagJsonSchemaField(stInteger, 'PoradoveCislo', 'Poradove cislo', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property PoradoveCislo: integer read FPoradoveCislo write FPoradoveCislo;

    [MVCColumn('Kategorie')]
    [MVCSwagJsonSchemaField(stString, 'Kategorie', 'Kategorie aktivity', true, false, 0, 3)]
    property Kategorie: string read FKategorie write FKategorie;

    [MVCColumn('Predmet')]
    [MVCSwagJsonSchemaField(stString, 'Predmet', 'Předmět aktivity', true, false, 0, 255)]
    property Predmet: string read FPredmet write FPredmet;

    [MVCColumn('Typ')]
    [MVCSwagJsonSchemaField(stString, 'Typ', 'Kód typu', true, false, 1, 3)]
    property Typ: string read FTyp write FTyp;

    [MVCColumn('Stav')]
    [MVCSwagJsonSchemaField(stString, 'Stav', 'Kód stavu', true, false, 1, 3)]
    property Stav: string read FStav write FStav;

    [MVCColumn('DruhVystupu')]
    [MVCSwagJsonSchemaField(stString, 'DruhVystupu', 'Kód druhu výstupu', true, false, 1, 3)]
    property DruhVystupu: string read FDruhVystupu write FDruhVystupu;

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

    [MVCColumn('CisloZam')]
    [MVCSwagJsonSchemaField(stInteger, 'CisloZam', 'Číslo zaměstnance', false, true)]
    property CisloZam: NullableInt32 read FCisloZam write FCisloZam;

    [MVCColumn('CisloKontOsoba')]
    [MVCSwagJsonSchemaField(stInteger, 'CisloKontOsoba', 'Číslo kontaktní osoby', false, true)]
    property CisloKontOsoba: NullableInt32 read FCisloKontOsoba write FCisloKontOsoba;

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

    [MVCColumn('NakladOkruh')]
    [MVCSwagJsonSchemaField(stString, 'NakladOkruh', 'Nákladový okruh', false, true, 1, 30)]
    property NakladOkruh: NullableString read FNakladOkruh write FNakladOkruh;

    [MVCColumn('MistoKonani')]
    [MVCSwagJsonSchemaField(stString, 'MistoKonani', 'Místo jednání', true, false, 0, 255)]
    property MistoKonani: string read FMistoKonani write FMistoKonani;

    [MVCColumn('DatumJednOd')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumJednOd', 'Datum jednání (od)', false, true)]
    property DatumJednOd: NullableTDateTime read FDatumJednOd write FDatumJednOd;

    [MVCColumn('DatumJednDo')]
    [MVCSwagJsonSchemaField(stDateTime, 'DatumJednDo', 'Datum jednání (do)', false, true)]
    property DatumJednDo: NullableTDateTime read FDatumJednDo write FDatumJednDo;

    [MVCColumn('IDSouvisKJ')]
    [MVCSwagJsonSchemaField(stInteger, 'IDSouvisKJ', 'ID související aktivity', false, true)]
    property IDSouvisKJ: NullableInt32 read FIDSouvisKJ write FIDSouvisKJ;

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

    [MVCColumn('IDCis1')]
    [MVCSwagJsonSchemaField(stInteger, 'IDCis1', 'ID karty majetku', false, true)]
    property IDCis1: NullableInt32 read FIDCis1 write FIDCis1;

    [MVCColumn('IDCis2')]
    [MVCSwagJsonSchemaField(stInteger, 'IDCis2', 'ID karty majetku', false, true)]
    property IDCis2: NullableInt32 read FIDCis2 write FIDCis2;

    [MVCColumn('IDCis3')]
    [MVCSwagJsonSchemaField(stInteger, 'IDCis3', 'ID QMS číselníku 3', false, true)]
    property IDCis3: NullableInt32 read FIDCis3 write FIDCis3;

    [MVCColumn('IDMajetek')]
    [MVCSwagJsonSchemaField(stInteger, 'IDMajetek', 'ID karty majetku', false, true)]
    property IDMajetek: NullableInt32 read FIDMajetek write FIDMajetek;

    [MVCColumn('IDKmenZbozi')]
    [MVCSwagJsonSchemaField(stInteger, 'IDKmenZbozi', 'ID kmenové karty', false, true)]
    property IDKmenZbozi: NullableInt32 read FIDKmenZbozi write FIDKmenZbozi;

    [MVCColumn('IDStavSkladu')]
    [MVCSwagJsonSchemaField(stInteger, 'IDStavSkladu', 'ID skladové karty', false, true)]
    property IDStavSkladu: NullableInt32 read FIDStavSkladu write FIDStavSkladu;

    [MVCColumn('IDVyrCS')]
    [MVCSwagJsonSchemaField(stInteger, 'IDVyrCS', 'ID výrobního čísla', false, true)]
    property IDVyrCS: NullableInt32 read FIDVyrCS write FIDVyrCS;

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

    [MVCListOf(TUkolAktivity)]
    property Ukoly: TObjectList<TUkolAktivity> read FUkoly write SetUkoly;

  end;




  TQMSCiselnik = class(THeliosObjekty)
   private
    FCislo: string;
    FAgenda: NullableInt32;
    FCiselnik: integer;
    FPoznamka: NullableString;
   public
    [MVCColumn('Cislo')]
    [MVCSwagJsonSchemaField(stString, 'Cislo', 'Číslo', true, false, 1, 3)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property Cislo: string read FCislo write FCislo;

    [MVCColumn('Ciselnik')]
    [MVCSwagJsonSchemaField(stInteger, 'Ciselnik', 'Číselník', true, false)]
    property Ciselnik: integer read FCiselnik write FCiselnik;

    [MVCColumn('IDQMS')]
    [MVCSwagJsonSchemaField(stInteger, 'Agenda', 'Agenda (0-měřidla, 1-zařízení)', false, true)]
    property Agenda: NullableInt32 read FAgenda write FAgenda;

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

  end;




  TQMSUdrzbaStrojuAZarizeni = class(TAktivita)
   private
//    FIDCis1: NullableInt32;
    FDruhZarizeniKod: NullableString;

   protected
    procedure OnAfterLoad; virtual;
   public
{
    [MVCColumn('PoradoveCislo')]
    [MVCSwagJsonSchemaField(stInteger, 'PoradoveCislo', 'Poradove cislo', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property PoradoveCislo: integer read FPoradoveCislo write FPoradoveCislo;
}
{
    [MVCColumn('IDCis1')]
    [MVCSwagJsonSchemaField(stInteger, 'IDCis1', 'ID z QMS číselníku 1', false, true)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property IDCis1: NullableInt32 read FIDCis1 write FIDCis1;
}
    [MVCColumn('DruhZarizeniKod')]
    [MVCSwagJsonSchemaField(stString, 'DruhZarizeniKod', 'Kód/číslo druhu zařízení', false, true, 1, 3)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property DruhZarizeniKod: NullableString read FDruhZarizeniKod;
  end;




  [MVCNameCase(ncLowerCase)]
  TZamestnanec = class(THeliosObjekty)
   private
    FOsCislo: integer;
    FPrijmeni: string;
    FJmeno: string;
    FTitulPred: string;
    FTitulZa: string;
    FLogin: string;
    FStredisko: NullableString;
    FNaklOkruh: NullableString;
    FZakazka: NullableString;
    FKodCipu: NullableString;
   public
    procedure CheckInsert; override;
    procedure CheckUpdate; override;
    procedure CheckDelete; override;

    constructor Create; // nastaveni Default hodnot
{
    [MVCColumn('ID')]
//    [MVCTableField('ID', [foPrimaryKey])]
    [MVCSwagJsonSchemaField(stInteger, 'ID', 'ID', true, false)] // typ, sysName, nazev, required, nullable, minLength, maxLength
    property ID: integer read FID write FID;
}
    [MVCColumn('Cislo')] // 2nd param=true if is PrimaryKey
    [MVCSwagJsonSchemaField(stInteger, 'Cislo', 'Osobní číslo', true, false)]
    property OsCislo: integer read FOsCislo write FOsCislo;

    [MVCColumn('Jmeno')]
    [MVCSwagJsonSchemaField(stString, 'Jmeno', 'Jméno zaměstnance', false, false, 1, 100)]
    property Jmeno: string read FJmeno write FJmeno;

    [MVCColumn('Prijmeni')]
    [MVCSwagJsonSchemaField(stString, 'Prijmeni', 'Příjmení zaměstnance', false, false, 1, 100)]
    property Prijmeni: string read FPrijmeni write FPrijmeni;

    [MVCColumn('LoginId')]
    [MVCSwagJsonSchemaField(stString, 'LoginId', 'Login v Helios', false, false, 1, 128)]
    property Login: string read FLogin write FLogin;

    [MVCColumn('TitulPred')]
    [MVCSwagJsonSchemaField('TitulPred', 'Titul před', false, false, 1, 100)]
    property TitulPred: string read FTitulPred write FTitulPred;

    [MVCColumn('TitulZa')]
    [MVCSwagJsonSchemaField(stString, 'TitulZa', 'Titul za', false, false, 1, 100)]
    property TitulZa: string read FTitulZa write FTitulZa;

    [MVCColumn('Stredisko')]
    [MVCSwagJsonSchemaField(stString, 'Stredisko', 'Útvar', false, true, 1, 30)]
    property Stredisko: NullableString read FStredisko write FStredisko;

    [MVCColumn('NakladovyOkruh')]
    [MVCSwagJsonSchemaField(stString, 'NakladovyOkruh', 'Nákladový okruh', false, true, 1, 15)]
    property NakladovyOkruh: NullableString read FNaklOkruh write FNaklOkruh;

    [MVCColumn('Zakazka')]
    [MVCSwagJsonSchemaField(stString, 'Zakazka', 'Útvar', false, true, 1, 15)]
    property Zakazka: NullableString read FZakazka write FZakazka;

    [MVCColumn('KodCipu')]
    [MVCSwagJsonSchemaField(stString, 'KodCipu', 'Kód čipu zaměstnance', false, true, 1, 36)]
    property KodCipu: NullableString read FKodCipu write FKodCipu;
  end;



  TPrepocetMJ = class(THeliosObjekty)
   private
    FKodMJ1, FKodMJ2: string;
    FMnozHlavni, FMnozOdvoz: Single;
    FDatPorizeni: TDatetime;
   public
    [MVCColumn('KodMJ1')]
    [MVCSwagJsonSchemaField(stString, 'KodMJ1', 'MJ hlavní měrné jednotky', true, false, 1, 3)] // FieldName, Description, Required, Nullable, MinLength, MaxLength
    property KodMJ1: string read FKodMJ1 write FKodMJ1;

    [MVCColumn('KodMJ2')]
    [MVCSwagJsonSchemaField(stString, 'KodMJ2', 'MJ odvozené měrné jednotky', true, false, 1, 3)]
    property KodMJ2: string read FKodMJ2 write FKodMJ2;

    [MVCColumn('PocetHlavni')]
    [MVCSwagJsonSchemaField('PocetHlavni', 'Množství hlavní jednotky', true, false)]
    property PocetHlavni: Single read FMnozHlavni write FMnozHlavni;

    [MVCColumn('PocetOdvozene')]
    [MVCSwagJsonSchemaField('PocetOdvozene', 'Množství odvozené jednotky', true, false)]
    property PocetOdvozene: Single read FMnozOdvoz write FMnozOdvoz;
  end;





  TDruhSkladuEnum = (drsklSluzba, drsklGLobal, drsklFIFO, drsklPrumer, drsklCelniSklad);

  [MVCNameCase(ncLowerCase)]
  TSkupinaKaret = class(THeliosObjekty)
   private
//    FID: integer;
    FSkupZbo: string;
    FNazev: string;
    FDilec: boolean;
//    FDruhSkladu: TDruhSkladuEnum;
    FAutocislovani: Boolean;
   public
    [MVCColumn('SkupZbo')]
    [MVCSwagJsonSchemaField('SkupZbo', 'Skupina karet/zboží', true, false, 1, 3)] // FieldName, Description, Required, Nullable, MinLength, MaxLength
    property SkupZbo: string read FSkupZbo write FSkupZbo;

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

    [MVCColumn('Dilec')]
    [MVCSwagJsonSchemaField('Dilec', 'Dílec', true, false)]
    property Dilec: boolean read FDilec write FDilec default false;

    [MVCColumn('Autocislovani')]
    [MVCSwagJsonSchemaField('Autocislovani', 'Autočíslování', true, false)]
    property Autocislovani: boolean read FAutocislovani write FAutocislovani default false;

{
    [MVCEnumSerializationType(estEnumMappedValues, 'Služba, Podle globální konfigurace, FIFO, Průměry, Celní sklad')]
    [MVCColumn('DruhSkladu')]
    [MVCSwagJSONSchemaField(stEnumeraion, '', '', true, false)]
    property DruhSkladu: TDruhSkladuEnum read FDruhSkladu write FDruhSkladu;
}
  end;





  [MVCNameCase(ncLowerCase)]
  [MVCTable('TabKmenZbozi')]
  TKmenZbozi = class(THeliosObjekty)
   private
    FSkupZbo: string;
    FRegCis: string;
    FNazev1: string;
    FNazev2: string;
    FNazev3: string;
    FNazev4: string;
    FMJEvidence: string;
    FVykres: NullableString;
    FSKP: string;
    FPLUKod: string;
    FDilec: boolean;
    FMaterial: boolean;
    FNaradi: boolean;
    FHmotnost: Double;
    FPoznamka: NullableString;
    FBlokovano: boolean;
{$IFDEF CUSTOM_CTRL_Rootvin}
    FTypDilce: NullableString;
{$ENDIF}
    procedure NastavDilecMaterial(const Index: integer; const Value: boolean);
  public
    procedure CheckInsert; override;
    procedure CheckUpdate; override;
    procedure CheckDelete; override;

    [MVCColumn('SkupZbo')]
    [MVCSwagJsonSchemaField('SkupZbo', 'Skupina karet/zboží', true, false, 1, 3)] // FieldName, Description, Required, Nullable, MinLength, MaxLength
    property SkupZbo: string read FSkupZbo write FSkupZbo;

    [MVCColumn('RegCis')]
    [MVCSwagJsonSchemaField('RegCis', 'Registrační číslo', true, false, 1, 30)]
    property RegCis: string read FRegCis write FRegCis;

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

    [MVCColumn('Nazev2')]
    property Nazev2: string read FNazev2 write FNazev2;

    [MVCColumn('Nazev3')]
    property Nazev3: string read FNazev3 write FNazev3;

    [MVCColumn('Nazev4')]
    property Nazev4: string read FNazev4 write FNazev4;

    [MVCColumn('MJEvidence')]
    property MJEvidence: string read FMJEvidence write FMJEvidence;

    [MVCColumn('Vykres')]
    [MVCSwagJsonSchemaField(stString, 'Vykres', 'Výkres', false, true, 0, 35)]
    property Vykres: NullableString read FVykres write FVykres;

    [MVCColumn('PLUKod')]
    [MVCSwagJsonSchemaField(stString, 'PLUKod', 'PLU kód', false, false, 0, 10)]
    property PLUKod: string read FPLUKod write FPLUKod;

    [MVCColumn('SKP')]
    [MVCSwagJsonSchemaField(stString, 'SKP', 'Doplňkový kód', false, false, 0, 50)]
    property SKP: string read FSKP write FSKP;

    [MVCColumn('Dilec')]
    [MVCSwagJsonSchemaField(stBoolean, 'Dilec', 'Dílec', true, false)]
    property Dilec: Boolean read FDilec write FDilec;

    [MVCColumn('Material')]
    [MVCSwagJsonSchemaField(stBoolean, 'Material', 'Materiál', true, false)]
    property Material: Boolean read FMaterial write FMaterial;

    [MVCColumn('Sluzba')]
    [MVCSwagJsonSchemaField(stBoolean, 'Sluzba', 'Služba', true, false)]
    property Sluzba: Boolean read FMaterial write FMaterial;

    [MVCColumn('Naradi')]
    [MVCSwagJsonSchemaField('Naradi', 'Nářadí', true, false)]
    property Naradi: Boolean read FNaradi write FNaradi;

    [MVCColumn('Hmotnost')]
    [MVCSwagJsonSchemaField('Hmotnost', 'Hmotnost', true, false)]
    property Hmotnost: Double read FHmotnost write FHmotnost;

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

    [MVCColumn('Blokovano')]
    [MVCSwagJsonSchemaField('Blokovano', 'Blokovnáno', true, false)]
    property Blokovano: Boolean read FBlokovano write FBlokovano;

{$IFDEF CUSTOM_CTRL_Rootvin}
    [MVCColumn('TypDilce')]
    [MVCSwagJsonSchemaField('TypDilce', 'Typ dílce', false, true)] // 1-Surovina / 2-Polotovar / 3-Obal
    property TypDilce: NullableString read FTypDilce write FTypDilce;
{$ENDIF}
  end;




  TOrgPravniFormaEnum = (opfPravnickaOsoba, opfFyzickaOsoba, opfSoukromaOsoba, opfNeurceno);
  TOrgStav = (osAktivni, osBlokovano, osZakaz, osPotencial);

  [MVCNameCase(ncLowerCase)]
  TOrganizace = class(THeliosObjekty)
   private
    FPravniForma: TOrgPravniFormaEnum;
    FNazev: string;
    FICO: string;
    FDIC: string;
    FUlice: string;
    FPopCislo: string;
    FOrCislo: string;
    FUliceSCisly: string;
    FMisto: string;
    FPSC: string;
//    FStav: TOrgStav;
    FStav: byte;
    procedure SetUlice(Value: string);
    procedure SetPopCislo(Value: string);
    procedure SetOrCislo(Value: string);
    procedure SetUliceSCisly(Value: string);
   public
    procedure CheckInsert; override;
    procedure CheckUpdate; override;
    procedure CheckDelete; override;

    [MVCColumn('PravniForma')]
    [MVCEnumSerialization(estEnumMappedValues, 'Právnická.osoba,Fyzická.osoba,Soukromá.osoba,Neurčeno')]
    property PravniForma: TOrgPravniFormaEnum read FPravniForma write FPravniForma;

    [MVCColumn('Nazev')]
    property Nazev: string read FNazev write FNazev;

    [MVCColumn('ICO')]
    property ICO: string read FICO write FICO;

    [MVCColumn('DIC')]
    property DIC: string read FDIC write FDIC;

    [MVCColumn('Ulice')]
    property Ulice: string read FUlice write SetUlice;

    [MVCColumn('PopCislo')]
    property PopCislo: string read FPopCislo write SetPopCislo;

    [MVCColumn('OrCislo')]
    property OrCislo: string read FOrCislo write SetOrCislo;

    [MVCColumn('UliceSCisly')]
    property UliceSCisly: string read FUliceSCisly;

    [MVCColumn('Misto')]
    property Misto: string read FMisto write FMisto;

    [MVCColumn('PSC')]
    property PSC: string read FPSC write FPSC;
{
    [MVCColumn('Stav')]
    [MVCEnumSerialization(estEnumMappedValues, 'Aktivní,Blokovaná,Zakázaná,Potencionální')]
    property Stav: TOrgStav read FStav write FStav;
}
    [MVCColumn('Stav')]
    property Stav: byte read FStav write FStav;
  end;




implementation

uses
  System.SysUtils,
  System.StrUtils,
  System.RegularExpressions;





{ THeliosObjekty }
 constructor THeliosObjekty.Create;
  begin
   FAVAReferenceID:= '';
   FAVAExternalID:= '';
  end;

 procedure THeliosObjekty.OnAfterLoad;
  begin
  end;

 procedure THeliosObjekty.OnBeforeLoad;
  begin
  end;

 procedure THeliosObjekty.OnBeforeInsert;
  begin
  end;

 procedure THeliosObjekty.OnAfterInsert;
  begin
  end;

 procedure THeliosObjekty.OnBeforeUpdate;
  begin
  end;

 procedure THeliosObjekty.OnAfterUpdate;
  begin
  end;

 procedure THeliosObjekty.OnBeforeDelete;
  begin
  end;

 procedure THeliosObjekty.OnAfterDelete;
  begin
  end;

 procedure THeliosObjekty.OnBeforeInsertOrUpdate;
  begin
  end;

 procedure THeliosObjekty.OnBeforeExecuteSQL(var SQL: string);
  begin
  end;

 procedure THeliosObjekty.OnAfterInsertOrUpdate;
  begin
  end;

 procedure THeliosObjekty.CheckDelete;
  begin
  end;

 procedure THeliosObjekty.CheckInsert;
  begin
  end;

 procedure THeliosObjekty.CheckUpdate;
  begin
  end;

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






{ TUmisteni }
 constructor TUmisteni.Create;
  begin
   inherited;
  end;

 destructor TUmisteni.Destroy;
  begin
   inherited;
  end;






{ TPohybOZ }
 constructor TPohybOZ.Create;
  begin
   inherited;
   FSerialNums:= TObjectList<TSerioveCisloPohybOZ>.Create;
  end;


 destructor TPohybOZ.Destroy;
  begin
//   if (FSerialNums<>nil) then
//    FSerialNums.Free;
   inherited;
  end;


 procedure TPohybOZ.SetSerialNums (const Value: TObjectList<TSerioveCisloPohybOZ>);
  begin
   if (Value<>FSerialNums) then
    begin
     FSerialNums.Free;
     FSerialNums:= Value;
    end;
  end;


 procedure TPohybOZ.SetUmisteni (const Value: TUmisteni);
  begin
   if (Value<>FUmisteni) then
    begin
     FUmisteni.Free;
     FUmisteni:= Value;
    end;
  end;


 procedure TPohybOZ.ZapisIDKmene;
  begin
  end;




{ TDokladOZ }


 constructor TDokladOZ.Create;
  begin
   inherited;
   FPohybyOZ:= TObjectList<TPohybOZ>.Create;
  end;


 destructor TDokladOZ.Destroy;
  begin
//   if (FPohybyOZ<>nil) then
//    FPohybyOZ.Free;
   inherited;
  end;


 procedure TDokladOZ.SetPohybyOZ(const Value: TObjectList<TPohybOZ>);
  begin
   if (Value<>FPohybyOZ) then
    begin
     FPohybyOZ.Free;
     FPohybyOZ:= Value;
    end;
  end;





{ TSkupinaZbozi }







{ TZamestnanec }
 constructor TZamestnanec.Create;
  begin
   inherited;
   FJmeno:= '';
   FPrijmeni:= '';
   FLogin:= '';
   FTitulPred:= '';
   FTitulZa:= '';
  end;


 procedure TZamestnanec.CheckInsert;
  begin
   inherited;
  end;


 procedure TZamestnanec.CheckUpdate;
  begin
   inherited;
   CheckInsert;
  end;


 procedure TZamestnanec.CheckDelete;
  begin
   inherited;
{
   if Price <= 5 then
    raise Exception.Create('Cannot delete an article with a price below 5 euros (yes, it is a silly check)');
}
  end;






{ TKmenZbozi }
 procedure TKmenZbozi.CheckInsert;
  begin
   inherited;
  end;


 procedure TKmenZbozi.CheckUpdate;
  begin
   inherited;
  end;


 procedure TKmenZbozi.CheckDelete;
  begin
   inherited;
  end;


 procedure TKmenZbozi.NastavDilecMaterial (const Index: Integer; const Value: Boolean);
  begin
   case Index of
    1: FDilec:= Value;
    2: FMaterial:= Value;
   end;
  end;









{ TOrganizace }
 procedure TOrganizace.CheckInsert;
  begin
   inherited;
  end;


 procedure TOrganizace.CheckUpdate;
  begin
   inherited;
   CheckInsert;
  end;


 procedure TOrganizace.CheckDelete;
  begin
   inherited;
  end;


 procedure TOrganizace.SetUlice(Value: string);
  begin
   FUlice:= Value;
   SetUliceSCisly('');
  end;


 procedure TOrganizace.SetPopCislo(Value: string);
  begin
   FPopCislo:= Value;
   SetUliceSCisly('');
  end;


 procedure TOrganizace.SetOrCislo(Value: string);
  begin
   FOrCislo:= Value;
   SetUliceSCisly('');
  end;


 procedure TOrganizace.SetUliceSCisly (Value: string);
  begin
   if (Value<>'') then
     FUliceSCisly:= Value
    else
     FUliceSCisly:= IfThen(FUlice<>'', FUlice, '') + ' '
                  + IfThen((FPopCislo<>'') and (FOrCislo<>''), FPopCislo + ' / ' + FOrCislo, IfThen(FPopCislo<>'', FPopCislo, IfThen(FOrCislo<>'', FOrCislo, '')));
  end;







{ TPlanKalendar }
 constructor TPlanKalendar.Create;
  begin
   inherited;
   FPolozky:= TObjectList<TPolozkaPlanKal>.Create;
  end;


 destructor TPlanKalendar.Destroy;
  begin
//   if (FPolozky<>nil) then
//    FPolozky.Free;
   inherited;
  end;


 procedure TPlanKalendar.SetPolozkyKalendare (const Value: TObjectList<TPolozkaPlanKal>);
  begin
   if (Value<>FPolozky) then
    begin
     FPolozky.Free;
     FPolozky:= Value;
    end;
  end;








{ TQMSUdrzbaStrojuAZarizeni }
 procedure TQMSUdrzbaStrojuAZarizeni.OnAfterLoad;
  begin
   FDruhZarizeniKod:= '';
   if not(Self.FIDCis1=nil) then
    begin
     FDruhZarizeniKod:= '';
    end;
  end;







{ TUkolAktivity }
 constructor TUkolAktivity.Create;
  begin
   inherited;
   FPredmet:= '';
   HotovoProcent:= 0;
  end;


 destructor TUkolAktivity.Destroy;
  begin
//   if (FUkoly<>nil) then
//    FUkoly.Free;
   inherited;
  end;






{ TAktivita }
 constructor TAktivita.Create;
  begin
   inherited;
   FUkoly:= TObjectList<TUkolAktivity>.Create;
  end;


 destructor TAktivita.Destroy;
  begin
//   if (FUkoly<>nil) then
//    FUkoly.Free;
   inherited;
  end;


 procedure TAktivita.SetUkoly (const Value: System.Generics.Collections.TObjectList<TUkolAktivity>);
  begin
   if (Value<>FUkoly) then
    begin
     FUkoly.Free;
     FUkoly:= Value;
    end;
  end;



end.