2838 lines
102 KiB
ObjectPascal
2838 lines
102 KiB
ObjectPascal
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.
|