unit P3ObjPPC;

interface

uses P3ObjCon,Classes,P3Obj001,P3ObjCis,P3AncSQL,P3Types,P3Sys001,SysUtils,P3ObjPLog,P3ObjUzi;

{TKvaTypUkolu}
type  TKvaTypUkolu=class(TKvaColumnList)
      private
        function GetSmallInt(const Index: Integer): SmallInt;
        procedure SetSmallint(const Index: Integer; const Value: Smallint);
        function GetInteger(const Index: Integer): Integer;
        procedure SetInteger(const Index, Value: Integer);
        function GetString(const Index: Integer): String;
        procedure SetString(const Index: Integer; const Value: String);
        function GetIntBit(Index:Integer):Boolean;
        procedure SetIntBit(Index:Integer;Value:Boolean);
      public
        constructor Create(AOwner:TComponent);override;
        destructor Destroy;override;
        procedure Save;override;
        property typuko:SmallInt index 0 read GetSmallInt write SetSmallint;
        property naztyp:String index 1 read GetString write SetString;
        property zkrtyp:String index 2 read GetString write SetString;
        property primap:Integer index 3 read GetInteger write SetInteger;
        property sysope:SmallInt index 4 read GetSmallInt write SetSmallInt;
        property PouzitoSysope:Boolean index 0 read GetIntBit write SetIntBit;
      end;

{TKvaTypUkoluList}
type  TKvaTypUkoluListSQL=class;
      TKvaTypUkoluList=class(TKvaObjectArray)
      private
        FSQL:TKvaTypUkoluListSQL;
      protected
        function CreateElement:TKvaColumnList;override;
        function GetTypUkolu(Index: Integer): TKvaTypUkolu;
      public
         constructor Create(AOwner:TComponent);override;
         destructor Destroy;override;
         procedure Save;override;
         procedure Restore;override;
         property TypUkolu[Index:Integer]:TKvaTypUkolu read GetTypUkolu;
         function InsertRow(Index:Integer):Integer;override;
         function TypUkoluDleKodu(typuko:SmallInt):TKvaTypUkolu;
         function IndexUkoluDleKodu(typuko:SmallInt):Integer;
         function PocetUkoluDleKodu(typuko:SmallInt):Integer;
         function MaxKodDleKodu:SmallInt;
         property SQL:TKvaTypUkoluListSQL read FSQL;
      end;
      TKvaTypUkoluListSQL=class(TKvaSQL)
      public
        procedure Read;override;
        procedure Write;override;
      end;

{TKvaUkol}
type TKvaUkol=class(TKvaColumnList)
     private
       FPopis:TKvaText;
       FTypUkolu:TKvaTypUkolu;
       function GetInteger(Index:Integer):Integer;
       procedure SetInteger(Index:Integer;Value:Integer);
       function GetString(Index:Integer):String;
       procedure SetString(Index:Integer;Value:String);
       function GetSmallint(Index:Integer):Smallint;
       procedure SetSmallint(Index:Integer;Value:Smallint);
       function GetDecimal(Index:Integer):Double;
       procedure SetDecimal(Index:Integer;Value:Double);
       function GetDateTime(Index:Integer):TDateTime;
       procedure SetDateTime(Index:Integer;Value:TDateTime);
     protected
       property inpppc:Integer index 0 read GetInteger;
       property incipr:Integer index 1 read GetInteger write SetInteger;
       property nazuko:String index 2 read GetString write SetString;
       property typuko:Smallint index 3 read GetSmallint write SetSmallint;
       property TypUkolu:TKvaTypUkolu read FTypUkolu write FTypUkolu;
       property vazuko:Integer index  4 read GetInteger write SetInteger;
       property spevaz:Smallint index 5 read GetSmallint write SetSmallint;
       property datpln:TDateTime index 6 read GetDateTime write SetDateTime;
       property typuzi:Smallint index 7 read GetSmallint write SetSmallint;
       property odposa:Integer index 8 read GetInteger write SetInteger;
       property stauko:Smallint index 9 read GetSmallint write SetSmallint;
       property kfirma:Smallint index 10 read GetSmallint write SetSmallint;
       property castka:Double index 11 read GetDecimal write SetDecimal;
       property primap:Integer index 12 read GetInteger write SetInteger;
       property typzad:Smallint index 13 read GetSmallint write SetSmallint;
       property zadava:Integer index 14 read GetInteger write SetInteger;
       property datzad:TDateTime index 15 read GetDateTime write SetDateTime;
       property Popis:TKvaText read FPopis;
     public
       constructor Create(AOwner:TComponent);override;
       destructor Destroy;override;
       function PublicText:String;
       property Text;
       function Status:TKvaRowStatus;override;
       procedure Save;override;
       procedure Restore;override;
     end;
{TKvaUkolList}
     TKvaUkolList=class(TkvaObjectArray)
       FCiselniky:TKvaCiselnikList;
       FPLogin:TKvaPLoginList;
     protected
       function CreateElement:TKvaColumnList;override;
       function GetUkol(Index: Integer): TKvaUkol;
     public
       property Ciselniky:TKvaCiselnikList read FCiselniky write FCiselniky;
       property PLogin:TKvaPLoginList read FPLogin write FPLogin;
       function InsertRow(Index:Integer):Integer;override;
       property Ukol[Index:Integer]:TKvaUkol read GetUkol;
     end;

{TKvaUkolPracovnika}
     TKvaUkolPracovnika=class(TKvaUkol)
     public
       property inpppc;
       property incipr;
       property nazuko;
       property typuko;
       property vazuko;
       property spevaz;
       property datpln;
       property typuzi;
       property odposa;
       property stauko;
       property kfirma;
       property castka;
       property primap;
       property typzad;
       property zadava;
       property datzad;
       property Popis;
       constructor Create(AOwner:TComponent);override;
       destructor Destroy;override;
     end;
{TKvaUkolPracovnikaList}
     TKvaUkolPracovnikaListSQL=class;
     TKvaUkolPracovnikaList=class(TKvaObjectArray)
     private
       FCiselniky:TKvaCiselnikList;
       FPLoginList:TKvaPLoginList;
       FSQL:TKvaUkolPracovnikaListSQL;
       FUzivatelList:TKvaUzivatelList;
     protected
       function CreateElement:TKvaColumnList;override;
       function GetUkolPracovnika(Index: Integer): TKvaUkolPracovnika;
     public
       property UkolPracovnika[Index:Integer]:TKvaUkolPracovnika read GetUkolPracovnika;
       function InsertRow(Index:Integer):Integer;override;
       procedure DeleteRow(Index:Integer);override;
       constructor Create(AOwner:TComponent);override;
       destructor Destroy;override;
       property Ciselniky:TKvaCiselnikList read FCiselniky write FCiselniky;
       property PLoginList:TKvaPLoginList read FPLoginList write FPLoginList;
       property UzivatelList:TKvaUzivatelList read FUzivatelList write FUzivatelList;
       property SQL:TKvaUkolPracovnikaListSQL read FSQL;
       function UkolDleKodu(inpppc:Integer):TKvaUkolPracovnika;
       function IndexDleKodu(inpppc:Integer):Integer;
       procedure Clear;override;
       procedure Save;override;
       procedure Restore;override;
     end;
{TKvaUkolPracovnikaListSQL}
     TKvaUkolPracovnikaListSQL=class(TKvaSQL)
     public
       ReadType:Smallint;
       datref:TDateTime;
       TypUzivatele:Smallint;
       CtiPopis:Boolean;
       procedure Read;override;
       procedure Write;override;
     end;

{TKvaUkolZadavatel}
type TKvaUkolZadavatel=class(TKvaUkol)
     public
       property inpppc;
       property incipr;
       property nazuko;
       property typuko;
       property vazuko;
       property spevaz;
       property datpln;
       property typuzi;
       property odposa;
       property stauko;
       property kfirma;
       property castka;
       property primap;
       property typzad;
       property zadava;
       property datzad;
       property Popis;
       constructor Create(AOwner:TComponent);override;
     end;
{ TKvaUkolZadavatelList }
type TKvaUkolZadavatelListSQL=class;
     TKvaUkolZadavatelList=class(TKvaObjectArray)
     private
       FCiselniky:TKvaCiselnikList;
       FPLoginList:TKvaPLoginList;
       FSQL:TKvaUkolZadavatelListSQL;
       FUzivatelList:TKvaUzivatelList;
     protected
       function CreateElement:TKvaColumnList;override;
       function GetUkolZadavatel(Index: Integer): TKvaUkolZadavatel;
     public
       property SQL:TKvaUkolZadavatelListSQL read FSQL;
       property Ciselniky:TKvaCiselnikList read FCiselniky write FCiselniky;
       property PLoginList:TKvaPLoginList read FPLoginList write FPLoginList;
       property UzivatelList:TKvaUzivatelList read FUzivatelList write FUzivatelList;

       constructor Create(AOwner:TComponent);override;
       destructor Destroy;override;
       function InsertRow(Index:Integer):Integer;override;
       procedure DeleteRow(Index:Integer);override;
       property UkolZadavatel[Index:Integer]:TKvaUkolZadavatel read GetUkolZadavatel;
       function UkolDleKodu(inpppc:Integer):TKvaUkolZadavatel;
       function UkolExist(inpppc:Integer):Boolean;
       function IndexDleKodu(inpppc:Integer):Integer;
       procedure Clear;override;
     end;
{ TKvaUkolZadavatelListSQL }
     TKvaUkolZadavatelListSQL=class(TKvaSQL)
     public
       ReadType:Smallint;
       datref:TDateTime;
       TypUzivatele:Smallint;
       CtiPopis:Boolean;
       procedure Read;override;
       procedure Write;override;
     end;

{TKvaUkolOdpovednaOs}
type TKvaUkolOdpovednaOs=class(TKvaUkol)
     public
       property inpppc;
       property incipr;
       property nazuko;
       property typuko;
       property vazuko;
       property spevaz;
       property datpln;
       property typuzi;
       property odposa;
       property stauko;
       property kfirma;
       property castka;
       property primap;
       property typzad;
       property zadava;
       property datzad;
       property Popis;
       constructor Create(AOwner:TComponent);override;
     end;
{ TKvaUkolOdpovednaOsList }
type TKvaUkolOdpovednaOsListSQL=class;
     TKvaUkolOdpovednaOsList=class(TKvaObjectArray)
     private
       FCiselniky:TKvaCiselnikList;
       FPLoginList:TKvaPLoginList;
       FSQL:TKvaUkolOdpovednaOsListSQL;
       FUzivatelList:TKvaUzivatelList;
     protected
       function CreateElement:TKvaColumnList;override;
       function GetUkolOdpovednaOs(Index: Integer): TKvaUkolOdpovednaOs;
     public
       property SQL:TKvaUkolOdpovednaOsListSQL read FSQL;
       property Ciselniky:TKvaCiselnikList read FCiselniky write FCiselniky;
       property PLoginList:TKvaPLoginList read FPLoginList write FPLoginList;
       property UzivatelList:TKvaUzivatelList read FUzivatelList write FUzivatelList;

       constructor Create(AOwner:TComponent);override;
       destructor Destroy;override;
       function InsertRow(Index:Integer):Integer;override;
       procedure DeleteRow(Index:Integer);override;
       property UkolOdpovednaOs[Index:Integer]:TKvaUkolOdpovednaOs read GetUkolOdpovednaOs;
       function UkolDleKodu(inpppc:Integer):TKvaUkolOdpovednaOs;
       function UkolExist(inpppc:Integer):Boolean;
       function IndexDleKodu(inpppc:Integer):Integer;
       procedure Clear;override;
     end;
{ TKvaUkolOdpovednaOsListSQL }
     TKvaUkolOdpovednaOsListSQL=class(TKvaSQL)
     public
       ReadType:Smallint;
       datref:TDateTime;
       TypUzivatele:Smallint;
       CtiPopis:Boolean;
       procedure Read;override;
       procedure Write;override;
     end;

implementation

uses P3ObjSQL, Math;

{TKvaTypUkolu}

constructor TKvaTypUkolu.Create(AOwner: TComponent);
begin
  inherited;
  Add(itSmallint, 'typuko',0,0,False);
  Add(itString,   'naztyp',80,0,False);
  Add(itString,   'zkrtyp',5,0,False);
  Add(itInteger,  'primap',0,0,False);
  Add(itSmallint, 'sysope',0,0,False);
end;

destructor TKvaTypUkolu.Destroy;
begin
  inherited
end;

procedure TKvaTypUkolu.Save;
begin
  inherited;
end;

function TKvaTypUkolu.GetSmallint(const Index: Integer): Smallint;
begin
  case Index of
    0:Result:=ItemByName('typuko').AsSmallint;
    4:Result:=ItemByName('sysope').AsSmallint;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaTypUkolu.SetSmallint(const Index: Integer; const Value: Smallint);
begin
  case Index of
    0:if Value<>typuko then
      begin
        ItemByName('typuko').AsSmallint:=Value;
      end;
    5:if Value<>sysope then
      begin
        ItemByName('sysope').AsSmallint:=Value;
      end;
  end;
end;

function TKvaTypUkolu.GetIntBit(Index:Integer):Boolean;
var PomIntItem:TKvaIntegerCol;
begin
   if index<=30 then
   begin
     PomIntItem:=TKvaIntegerCol(ItemByName('primap'));
     Result:=PomIntItem.Bits[Index];
   end
   else
    raise EKvaGetSet.Create
end;

procedure TKvaTypUkolu.SetIntBit(Index:Integer;Value:Boolean);
var PomIntItem:TKvaIntegerCol;
begin
  if index<=30 then
   begin
      PomIntItem:=TKvaIntegerCol(ItemByName('primap'));
      PomIntItem.Bits[index]:=Value;
   end;
end;


function TKvaTypUkolu.GetInteger(const Index: Integer): Integer;
begin
  case Index of
    3:Result:=ItemByName('primap').AsInteger;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaTypUkolu.SetInteger(const Index, Value: Integer);
begin
  case Index of
    3:if Value<>primap then
      begin
        ItemByName('primap').AsInteger:=Value;
      end;
  end;
end;

function TKvaTypUkolu.GetString(const Index: Integer): String;
begin
  case Index of
    1:Result:=ItemByName('naztyp').AsString;
    2:Result:=ItemByName('zkrtyp').AsString;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaTypUkolu.SetString(const Index: Integer; const Value: String);
begin
  case Index of
    1:if AnsiCompareStr(naztyp,Value)<>0 then
      begin
        ItemByName('naztyp').AsString:=Value;
      end;
    2:if AnsiCompareStr(zkrtyp,Value)<>0 then
      begin
        ItemByName('zkrtyp').AsString:=Value;
      end;
  end;
end;

{ TKvaTypUkoluList }

function TKvaTypUkoluList.CreateElement: TKvaColumnList;
begin
  Result:=TKvaTypUkolu.Create(self);
end;

function TKvaTypUkoluList.GetTypUkolu(Index: Integer): TKvaTypUkolu;
begin
   Result:=TKvaTypUkolu(GetRow(Index));
end;

function TKvaTypUkoluList.PocetUkoluDleKodu(typuko:SmallInt): Integer;
var PomTypUkolu:TKvaTypUkolu;
    i:Integer;
begin
  Result:=0;
  for i:=0 to NumRows-1 do
  begin
     PomTypUkolu:=TypUkolu[i];
     if PomTypUkolu.typuko=typuko then
     begin
       Result:=Result+1;
     end;
  end;
end;

function TKvaTypUkoluList.IndexUkoluDleKodu(typuko:SmallInt): Integer;
var PomTypUkolu:TKvaTypUkolu;
    i:Integer;
begin
  Result:=-1;
  for i:=0 to NumRows-1 do
  begin
     PomTypUkolu:=TypUkolu[i];
     if PomTypUkolu.typuko=typuko then
     begin
       Result:=i;
       Break;
     end;
  end;
end;

function TKvaTypUkoluList.TypUkoluDleKodu(typuko:SmallInt): TKvaTypUkolu;
var PomTypUkolu:TKvaTypUkolu;
    i:Integer;
begin
  Result:=nil;
  for i:=0 to NumRows-1 do
  begin
     PomTypUkolu:=TypUkolu[i];
     if PomTypUkolu.typuko=typuko then
     begin
       Result:=PomTypUkolu;
       Break;
     end;
  end;
end;

function TKvaTypUkoluList.MaxKodDleKodu: SmallInt;
var PomTypUkolu:TKvaTypUkolu;
    PomVetsiTyp: SmallInt;
    i:Integer;
begin
  Result:=-1;
  PomVetsiTyp:=-1;
  for i:=0 to Count-1 do
  begin
     PomTypUkolu:=TypUkolu[i];
     if PomTypUkolu.typuko>PomVetsiTyp then
     begin
       PomVetsiTyp:=PomTypUkolu.typuko;
     end;
  end;
  Result:=PomVetsiTyp;
end;

function TKvaTypUkoluList.InsertRow(Index:Integer):Integer;
begin
  Result:=inherited InsertRow(Index);
end;

constructor TKvaTypUkoluList.Create(AOwner:TComponent);
begin
  inherited Create(AOwner);
  FSQL:=TKvaTypUkoluListSQL.Create(self);
end;

destructor TKvaTypUkoluList.Destroy;
begin
  FSQL.Destroy;
  inherited;
end;

procedure TKvaTypUkoluList.Restore;
begin
  inherited;
end;

procedure TKvaTypUkoluList.Save;
var i:Integer;
begin
  for i:=0 to NumRows-1 do
    TypUkolu[i].Save;
  inherited;
end;


{ TKvaTypUkoluListSQL }

procedure TKvaTypUkoluListSQL.Read;
var Index,i:Integer;
    ZadText:String;
    TypUkoluList:TKvaTypUkoluList;
    TypUkolu:TKvaTypUkolu;
    Sel,SubSel:TKvaSelecter;
begin
  FError:=0;
  TypUkoluList:=TKvaTypUkoluList(Owner);
  TypUkoluList.Clear;
  Sel:=TKvaSelecter.Create(self);
  Sel.Database:=FConnect.DbUsr;
  try
    Sel.Sloupce:=TypUkoluList.Text;
    Sel.Tabulka:='csukol';
    Sel.Podminka:='';
    Sel.OrderBy:='';
    Sel.OpenCursor;                      //execute a nastavi kurzor na 1. řadek dat
    while Sel.SQLError<>100 do         //příznak konce selectovaných dat
    begin
      TypUkolu:=TypUkoluList.TypUkolu[TypUkoluList.InsertRow(TypUkoluList.Count)];
      Transfer(Sel,TypUkolu,0,TypUkolu.Count-1);
      Sel.Fetch;
    end;
    Sel.CloseCursor;
    TypUkoluList.Save;
  except
    on E:Exception do
    begin
      FError:=Sel.SQLError;
      raise;
    end;
  end;
end;

procedure TKvaTypUkoluListSQL.Write;
var i,j,k:Integer;
    TypUkoluList:TKvaTypUkoluList;
    TypUkolu:TKvaTypUkolu;
    Ins:TKvaInserter;
    Del:TKvaDeleter;
    Upd:TKvaUpdater;
    MyTransaction:boolean;

begin
  FError:=0;
  Ins:=nil;
  Del:=nil;
  Upd:=nil;
  TypUkoluList:=TKvaTypUkoluList(Owner);
   if FConnect.DbUsr.InTransaction then
      MyTransaction:=False
   else
    begin
    MyTransaction:=True;
    if MyTransaction then
      FConnect.DbUsr.StartTransaction;
    end;
  try
    for i:=TypUkoluList.Count-1 downto 0 do
    begin
      TypUkolu:=TypUkoluList.TypUkolu[i];
      case TypUkolu.Status of
      rsInsert:
        try
          if Ins=nil then
          begin
            Ins:=TKvaInserter.Create(self);
            Ins.Database:=FConnect.DbUsr;
            Ins.Tabulka:='csukol';
            Ins.Sloupce:=TypUkolu.Text;
          end;
          Transfer(Ins,TypUkolu,0,TypUkolu.Count-1,0);
          Ins.Insert;
        except
          on E:Exception do
          begin
            FError:=Ins.SQLError;
            raise;
          end;
        end;
      rsUpdate:
        try
          if TypUkolu.Change then
          begin
            if Upd=nil then
            begin
              Upd:=TKvaUpdater.Create(self);
              Upd.Database:=FConnect.DbUsr;
              Upd.Tabulka:='csukol';
            end;
            Upd.Sloupce:=TypUkolu.TextChange;
            Upd.Podminka:='typuko=:typuko';
            Upd.Hodnoty.ParamByName('typuko').AsSmallint:=TypUkolu.typuko;
            Transfer(Upd,TypUkolu,1,TypUkolu.Count-1);
            Upd.Update;
          end;
        except
          on E:Exception do
          begin
            FError:=Upd.SQLError;
            raise;
          end;
        end;
      rsDelete:
        try
          if Del=nil then
          begin
            Del:=TKvaDeleter.Create(self);
            Del.Database:=FConnect.DbUsr;
            Del.Tabulka:='csukol';
          end;
          Del.Podminka:='typuko=:typuko';
          Del.Hodnoty.ParamByName('typuko').AsSmallint:=TypUkolu.typuko;
          Del.Delete;
        except
          on E:Exception do
          begin
            FError:=Del.SQLError;
            raise;
          end;
        end;
      end;
    end;
  finally
    if Ins<>nil then
      Ins.Destroy;
    if Upd<>nil then
      Upd.Destroy;
    if Del<>nil then
      Del.Destroy;
    if MyTransaction then
    begin
      if FError=0 then
      begin
        FConnect.DbUsr.Commit;
        TypUkoluList.Save;
      end
      else
        FConnect.DbUsr.Rollback;
    end;
  end;
end;

(* TKvaUkol *)

destructor TKvaUkol.Destroy;
begin
  FPopis.Destroy;
  inherited
end;

function TKvaUkol.Status: TKvaRowStatus;
begin
   Result:=inherited Status;
   if (Result=rsNone) and (Popis.Change) then
      Result:=rsUpdate;
end;

procedure TKvaUkol.Save;
begin
  inherited;
  FPopis.Save;
end;

procedure TKvaUkol.Restore;
begin
  inherited;
  FPopis.Restore;
end;

constructor TKvaUkol.Create(AOwner:TComponent);
begin
  inherited Create(AOwner);
  Add(itInteger, 'inpppc',0,0,False);  (*0*)
  Add(itInteger, 'incipr',0,0,False);  (*1*)
  Add(itString,  'nazuko',80,0,False); (*2*)
  Add(itSmallint,'typuko',0,0,FAlse);  (*3*)
  Add(itInteger, 'vazuko',0,0,False);  (*4*)
  Add(itSmallint,'spevaz',0,0,False);  (*5*)
  Add(itDate,    'datpln',0,0,False);  (*6*)
  Add(itSmallint,'typuzi',0,0,False);  (*7*)
  Add(itInteger, 'odposa',0,0,False);  (*8*)
  Add(itSmallint,'stauko',0,0,False);  (*9*)
  Add(itSmallint,'kfirma',0,0,False);  (*10*)
  Add(itDecimal, 'castka',12,2,False); (*11*)
  Add(itInteger, 'primap',0,0,False);  (*12*)
  Add(itSmallint,'typzad',0,0,False);  (*13*)
  Add(itInteger, 'zadava',0,0,False);  (*14*)
  Add(itDate,    'datzad',0,0,False);  (*15*)
  FPopis:=TKvaText.Create;
end;

function TKvaUkol.GetInteger(Index:Integer):Integer;
begin
  case Index of
  0:   Result:=ItemByName('inpppc').AsInteger;
  1:   Result:=ItemByName('incipr').AsInteger;
  4:   Result:=ItemByName('vazuko').AsInteger;
  8:   Result:=ItemByName('odposa').AsInteger;
  12:  Result:=ItemByName('primap').AsInteger;
  14:  Result:=ItemByName('zadava').AsInteger;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaUkol.SetInteger(Index:Integer;Value:Integer);
begin
   case Index of
   1:    ItemByName('incipr').AsInteger:=Value;
   4:    ItemByName('vazuko').AsInteger:=Value;
   8:    ItemByName('odposa').AsInteger:=Value;
   12:   ItemByName('primap').AsInteger:=Value;
   14:   ItemByName('zadava').AsInteger:=Value;
   end;
end;


function TKvaUkol.GetSmallint(Index:Integer):SMallint;
begin
  case Index of
  3:   Result:=ItemByName('typuko').AsSmallint;
  5:   Result:=ItemByName('spevaz').AsSmallint;
  7:   Result:=ItemByName('typuzi').AsSmallint;
  9:   Result:=ItemByName('stauko').AsSmallint;
  10:  Result:=ItemByName('kfirma').AsSmallint;
  13:  Result:=ItemByName('typzad').AsSmallint;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaUkol.SetSmallint(Index:Integer;Value:Smallint);
begin
  case Index of
  3:   ItemByName('typuko').AsSmallint:=Value;
  5:   ItemByName('spevaz').AsSmallint:=Value;
  7:   ItemByName('typuzi').AsSmallint:=Value;
  9:   ItemByName('stauko').AsSmallint:=Value;
  10:  ItemByName('kfirma').AsSmallint:=Value;
  13:  ItemByName('typzad').AsSmallint:=Value;
  end;
end;

function TKvaUkol.GetDecimal(Index:Integer):Double;
begin
  case Index of
  11:  Result:=ItemByName('castka').AsDecimal;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaUkol.SetDecimal(Index:Integer;Value:Double);
begin
  case Index of
  11:  ItemByName('castka').AsDecimal:=Value;
  end;
end;

function TKvaUkol.GetString(Index:Integer):String;
begin
  case Index of
  2:   Result:=ItemByName('nazuko').AsString;
  else
    raise EKvaGetSet.Create
  end;
end;

procedure TKvaUkol.SetString(Index:Integer;Value:String);
begin
  case Index of
  2:   ItemByName('nazuko').AsString:=Value;
  end;
end;

function TKvaUkol.GetDateTime(Index:Integer):TDateTime;
begin
   case Index of
   6:  Result:=ItemByName('datpln').AsDate;
   15: Result:=ItemByName('datzad').AsDate;
   else
    raise EKvaGetSet.Create
   end;
end;

procedure TKvaUkol.SetDateTime(Index:Integer;Value:TDateTime);
begin
  case Index of
  6:   ItemByName('datpln').AsDate:=Value;
  15:  ItemByName('datzad').AsDate:=Value;
  end;
end;


function TKvaUkol.PublicText:String;
begin
  Result:=Text
end;

(* TKvaUkolList *)
function TKvaUkolList.CreateElement:TKvaColumnList;
begin
  Result:=TKvaUkol.Create(self);
end;

function TKvaUkolList.GetUkol(Index:Integer):TKvaUkol;
begin
  Result:=TKvaUkol(GetRow(Index));
end;

function TKvaUkolList.InsertRow(Index:Integer):Integer;
begin
  Result:=inherited InsertRow(Index);
end;

(* TKvaUkolPracovnika *)

constructor TKvaUkolPracovnika.Create(AOwner:TComponent);
begin
  inherited;
end;

destructor TKvaUkolPracovnika.Destroy;
begin
  inherited
end;


(* TKvaUkolPracovnikaList *)
constructor TKvaUkolPracovnikaList.Create(AOwner:TComponent);
begin
  inherited Create(AOwner);
  FSQL:=TKvaUkolPracovnikaListSQL.Create(self);
end;

function TKvaUkolPracovnikaList.CreateElement:TKvaColumnList;
begin
  Result:=TKvaUkolPracovnika.Create(self);
end;

function TKvaUkolPracovnikaList.InsertRow(Index:Integer):Integer;
begin
  Result:=inherited InsertRow(Index);
end;

procedure TKvaUkolPracovnikaList.DeleteRow(Index:Integer);
begin
  inherited;
end;

function TKvaUkolPracovnikaList.GetUkolPracovnika(Index:Integer):TKvaUkolPracovnika;
begin
   Result:=TKvaUkolPracovnika(GetRow(Index));
end;

procedure TKvaUkolPracovnikaList.Restore;
begin
  inherited;
end;

procedure TKvaUkolPracovnikaList.Save;
begin
  inherited;
end;

function TKvaUkolPracovnikaList.UkolDleKodu(inpppc:Integer):TKvaUkolPracovnika;
var PomUkol:TKvaUkolPracovnika;
    i:Integer;
begin
  Result:=nil;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolPracovnika[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=PomUkol;
       Break;
     end;
  end;
end;

function TKvaUkolPracovnikaList.IndexDleKodu(inpppc:Integer):Integer;
var PomUkol:TKvaUkolPracovnika;
    i:Integer;
begin
  Result:=-1;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolPracovnika[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=i;
       Break;
     end;
  end;
end;

destructor TKvaUkolPracovnikaList.Destroy;
begin
  FSQL.Destroy;
  inherited;
end;

procedure TKvaUkolPracovnikaList.Clear;
begin
  inherited;
end;


(* TKvaUkolPracovnikaListSQL *)
procedure TKvaUkolPracovnikaListSQL.Read;
var Selecter:TKvaSelecter;
    SubSelPopis:TKvaSelecter;
    UkolPracovnika:TKvaUkolPracovnika;
    UkolPracovnikaList:TKvaUkolPracovnikaList;
    i:Integer;
    CtiPopis:Boolean;
    Lstauko:Smallint;
    Ldatpln:TDateTime;
begin
  FError:=0;
  UkolPracovnikaList:=TKvaUkolPracovnikaList(Owner);
  UkolPracovnikaList.Clear;
  SubSelPopis:=nil;
  CtiPopis:=False;
  Selecter:=TKvaSelecter.Create(self);
  try
     Selecter.Database:=FConnect.DbUsr;
     Selecter.Sloupce:=UkolPracovnikaList.Text;
     Selecter.Tabulka:='pprppc';
     Selecter.OrderBy:='datpln,stauko';
     Selecter.Podminka:='kfirma=:kfirma and incipr=:inckey';
     Selecter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
     Selecter.Hodnoty.ParamByName('inckey').AsInteger:=FMasterKey;
     Selecter.OpenCursor;
     while Selecter.SQLError<>100 do
       begin
         case ReadType of
           0:
             begin
                Lstauko:=Selecter.Fields[9].AsInteger;
                Ldatpln:=Selecter.Fields[6].AsDateTime;
                if ((Lstauko in [1,2]) and (Ldatpln>=IncMonth(datref,-1))) or (Lstauko=0) then
                  begin
                    UkolPracovnika:=UkolPracovnikaList.UkolPracovnika[UkolPracovnikaList.InsertRow(UkolPracovnikaList.Count)];
                    Transfer(Selecter,UkolPracovnika,0,UkolPracovnika.Count-1);
                    CtiPopis:=True;
                  end
             end;
           1:
             begin
                UkolPracovnika:=UkolPracovnikaList.UkolPracovnika[UkolPracovnikaList.InsertRow(UkolPracovnikaList.Count)];
                Transfer(Selecter,UkolPracovnika,0,UkolPracovnika.Count-1);
                CtiPopis:=True;
             end;
         end;

         if CtiPopis then
            begin
             if SubSelPopis=nil then
              begin
                SubSelPopis:=TKvaSelecter.Create(self);;
                SubSelPopis.Database:=FConnect.DbUsr;
                SubSelPopis.Sloupce:='inpppc,cisrad,texrad';
                SubSelPopis.Tabulka:='pprppp';
                SubSelPopis.OrderBy:='cisrad';
                SubSelPopis.Podminka:='inpppc=:inpppc';
              end;
              SubSelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
              SubSelPopis.OpenCursor;
              i:=0;
               while SubSelPopis.SQLError<>100 do
               begin
                  if UkolPracovnika<>nil then
                  begin
                     UkolPracovnika.FPopis.Radek[i]:=SubSelPopis.Fields[2].AsFullString;
                     i:=i+1;         //standartní řešení Kvasaru
                  end;
                  SubSelPopis.Fetch;
               end;
               SubSelPopis.CloseCursor;
            end;
         CtiPopis:=False;
         Selecter.Fetch;
       end;
     Selecter.CloseCursor;
     Selecter.Destroy;
     if SubSelPopis<>nil then SubSelPopis.Destroy;
     UkolPracovnikaList.Save;
  except
    on E:Exception do
      begin
        FError:=Selecter.SQLError;
        raise;
      end;
  end;
end;

procedure TKvaUkolPracovnikaListSQL.Write;
var i,j:Integer;
    UkolPracovnikaList:TKvaUkolPracovnikaList;
    UkolPracovnika:TkvaUkolPracovnika;
    Inserter:TKvaInserter;
    Deleter:TKvaDeleter;
    Updater:TKvaUpdater;
    MyTransaction:boolean;
    SubInsPopis:TKvaInserter;
    SubDelPopis:TKvaDeleter;
    SubUpdPopis:TKvaUpdater;
    pomstr:String;
    LPomSub:Smallint;

procedure CreateSubPopis(Index:Integer);
 begin
   case Index of
     0:begin
         SubInsPopis:=TKvaInserter.Create(self);
         SubInsPopis.Database:=FConnect.DbUsr;
         SubInsPopis.Tabulka:='pprppp';
         SubInsPopis.Sloupce:='inpppc,cisrad,texrad';
        end;
     1:begin
         SubUpdPopis:=TKvaUpdater.Create(self);
         SubUpdPopis.Database:=FConnect.DbUsr;
         SubUpdPopis.Tabulka:='pprppp';
       end;
     2:begin
         SubDelPopis:=TKvaDeleter.Create(self);
         SubDelPopis.Database:=FConnect.DbUsr;
         SubDelPopis.Tabulka:='pprppp';
       end;
   end;
 end;

begin
   FError:=0;
   Inserter:=nil;
   Deleter:=nil;
   UpDater:=nil;
   SubInsPopis:=nil;
   SubDelPopis:=nil;
   SubUpdPopis:=nil;
   UkolPracovnikaList:=TKvaUkolPracovnikaList(Owner);
   if FConnect.DbUsr.InTransaction then
      MyTransaction:=False
   else
   begin
      MyTransaction:=True;
      if MyTransaction then
      FConnect.DbUsr.StartTransaction;
   end;
   try
      for i:=0 to UkolPracovnikaList.Count-1 do
      begin
         UkolPracovnika:=UkolPracovnikaList.UkolPracovnika[i];
         case UkolPracovnika.Status of
         rsInsert:
         try
            LPomSub:=1;
            if Inserter=nil then
            begin
               Inserter:=TKvaInserter.Create(self);
               Inserter.Database:=FConnect.DbUsr;
               Inserter.Tabulka:='pprppc';
               Inserter.Sloupce:=UkolPracovnika.Text;
               Inserter.Klic:='inpppc';
            end;
            Inserter.Hodnoty.ParamByName('inpppc').AsInteger:=0;
            Transfer(Inserter,UkolPracovnika,1,UkolPracovnika.Count-1);
            Inserter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
            Inserter.Insert;
            UkolPracovnika.ItemByName('inpppc').AsInteger:=Inserter.Serial;
            if SubInsPopis=nil then
            begin
               CreateSubPopis(0);
            end;
            for j:=0 to UkolPracovnika.Popis.Pocet-1 do
            begin
               LPomSub:=2;
               pomstr:=UkolPracovnika.Popis.Radek[j];
               SubInsPopis.Hodnoty.ParamByName('cisrad').AsSmallint:=j;
               SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
               SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=pomstr;
               SubInsPopis.Insert;
            end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Inserter.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsUpdate:
         try
            if UkolPracovnika.TextChange<>'' then
              begin
                LPomSub:=1;
                if Updater=nil then
                begin
                   Updater:=TKvaUpdater.Create(self);
                   Updater.Database:=FConnect.DbUsr;
                   Updater.Tabulka:='pprppc';
                end;
                Updater.Sloupce:=UkolPracovnika.TextChange;
                Updater.Podminka:='inpppc=:inpppc';
                Updater.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
                Transfer(UpDater,UkolPracovnika,0,UkolPracovnika.Count-1);
                Updater.Update;
              end;
            if UkolPracovnika.Popis.Change then
             begin
                if SubDelPopis=nil then
                   CreateSubPopis(2);
                SubDelPopis.Podminka:='inpppc=:inpppc';
                SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
                SubDelPopis.Delete;
                for j:=0 to UkolPracovnika.Popis.Pocet-1 do
                begin
                   LPomSub:=2;
                   if SubInsPopis=nil then
                      CreateSubPopis(0);
                   SubInsPopis.Hodnoty.ParamByName('cisrad').AsSmallint:=j;
                   SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=UkolPracovnika.Popis.Radek[j];
                   SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
                   SubInsPopis.Insert;
                end;
             end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Updater.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsDelete:
         try
            LPomSub:=1;
            if Deleter=nil then
            begin
               Deleter:=TKvaDeleter.Create(self);
               Deleter.Database:=FConnect.DbUsr;
               Deleter.Tabulka:='pprppc';
            end;
            Deleter.Podminka:='inpppc=:inpppc';
            Deleter.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
            Deleter.Delete;
            if SubDelPopis=nil then CreateSubPopis(2);
            LPomSub:=2;
            SubDelPopis.Podminka:='inpppc=:inpppc';
            SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolPracovnika.inpppc;
            SubDelPopis.Delete;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Deleter.SQLError;
               if LPomSub=2 then  FError:=SubDelPopis.SQLError;
               raise;
            end;
         end;
         end;
      end;
   finally
      if Inserter<>nil then
      Inserter.Destroy;
      if Updater<>nil then
      Updater.Destroy;
      if Deleter<>nil then
      Deleter.Destroy;
      if SubInsPopis<>nil then SubInsPopis.Destroy;
      if SubDelPopis<>nil then SubDelPopis.Destroy;
      if SubUpdPopis<>nil then SubUpdPopis.Destroy;
      if MyTransaction then
      begin
         if FError=0 then
         begin
            FConnect.DbUsr.Commit;
            UkolPracovnikaList.Save;
         end else
           FConnect.DbUsr.Rollback;
      end;
   end;
end;

(* TKvaUkolZadavatel *)

constructor TKvaUkolZadavatel.Create(AOwner:TComponent);
begin
  inherited;
end;

(* TKvaUkolZadavatelList *)

procedure TKvaUkolZadavatelList.Clear;
begin
  inherited;
end;

constructor TKvaUkolZadavatelList.Create(AOwner:TComponent);
begin
  inherited;
  FSQL:=TKvaUkolZadavatelListSQL.Create(self);
end;

destructor TKvaUkolZadavatelList.Destroy;
begin
  FSQL.Destroy;
  inherited
end;

function TKvaUkolZadavatelList.CreateElement:TKvaColumnList;
begin
  Result:=TKvaUkolZadavatel.Create(self);
end;

function TKvaUkolZadavatelList.GetUkolZadavatel(Index:Integer):TKvaUkolZadavatel;
begin
  Result:=TKvaUkolZadavatel(GetRow(Index));
end;

function TKvaUkolZadavatelList.InsertRow(Index:Integer):Integer;
var PomUkolZadavatel:TKvaUkolZadavatel;
begin
  Result:=inherited InsertRow(Index);
  PomUkolZadavatel:=UkolZadavatel[Result];
  PomUkolZadavatel.ItemByName('incipr').AsInteger:=0;
  PomUkolZadavatel.ItemByName('nazuko').AsString:=' ';
  PomUkolZadavatel.ItemByName('typuko').AsSmallint:=0;
  PomUkolZadavatel.ItemByName('datpln').AsDateTime:=cidMax;
  PomUkolZadavatel.ItemByName('typuzi').AsSmallint:=1;
  PomUkolZadavatel.ItemByName('odposa').AsInteger:=0;
  PomUkolZadavatel.ItemByName('stauko').AsSmallint:=0;
  PomUkolZadavatel.ItemByName('castka').AsDecimal:=0;
  PomUkolZadavatel.ItemByName('typzad').AsSmallint:=1;
  PomUkolZadavatel.ItemByName('zadava').AsInteger:=0;
  PomUkolZadavatel.ItemByName('datzad').AsDateTime:=Now;
end;

procedure TKvaUkolZadavatelList.DeleteRow(Index:Integer);
begin
  inherited;
end;

function TKvaUkolZadavatelList.UkolDleKodu(inpppc:Integer):TKvaUkolZadavatel;
var PomUkol:TKvaUkolZadavatel;
    i:Integer;
begin
  Result:=nil;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolZadavatel[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=PomUkol;
       Break;
     end;
  end;
end;

function TKvaUkolZadavatelList.UkolExist(inpppc:Integer):Boolean;
var PomUkol:TKvaUkolZadavatel;
    i:Integer;
begin
  Result:=False;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolZadavatel[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=True;
       Break;
     end;
  end;
end;

function TKvaUkolZadavatelList.IndexDleKodu(inpppc:Integer):Integer;
var PomUkol:TKvaUkolZadavatel;
    i:Integer;
begin
  Result:=-1;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolZadavatel[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=i;
       Break;
     end;
  end;
end;


(* TKvaUkolZadavatelListSQL *)
procedure TKvaUkolZadavatelListSQL.Read;
var Selecter:TKvaSelecter;
    SubSelPopis:TKvaSelecter;
    UkolZadavatel:TKvaUkolZadavatel;
    UkolZadavatelList:TKvaUkolZadavatelList;
    i,j,k,Lincuzi,Linpppc:Integer;
    Lstauko:Smallint;
    Ldatpln:TDateTime;
    LLogin:TKvaPLogin;
    LRole:TKvaPRole;
begin
  FError:=0;
  UkolZadavatelList:=TKvaUkolZadavatelList(Owner);
  UkolZadavatelList.Clear;
  SubSelPopis:=nil;
  CtiPopis:=False;
  Selecter:=TKvaSelecter.Create(self);
  try
     Selecter.Database:=FConnect.DbUsr;
     Selecter.Sloupce:=UkolZadavatelList.Text;
     Selecter.Tabulka:='pprppc';
     Selecter.OrderBy:='datpln,stauko';
     Selecter.Podminka:='kfirma=:kfirma and zadava=:inckey and typzad=:typzad';
     Selecter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
     Selecter.Hodnoty.ParamByName('inckey').AsInteger:=FMasterKey;
     Selecter.Hodnoty.ParamByName('typzad').AsInteger:=TypUzivatele;
     Selecter.OpenCursor;
     while Selecter.SQLError<>100 do
       begin
         case ReadType of
           0:
             begin
                Lstauko:=Selecter.Fields[9].AsInteger;
                Ldatpln:=Selecter.Fields[6].AsDateTime;
                if ((Lstauko in [1,2]) and (Ldatpln>=IncMonth(datref,-1))) or (Lstauko=0) then
                  begin
                    UkolZadavatel:=UkolZadavatelList.UkolZadavatel[UkolZadavatelList.InsertRow(UkolZadavatelList.Count)];
                    Transfer(Selecter,UkolZadavatel,0,UkolZadavatel.Count-1);
                    CtiPopis:=True;
                  end;
             end;
           1:
             begin
                UkolZadavatel:=UkolZadavatelList.UkolZadavatel[UkolZadavatelList.InsertRow(UkolZadavatelList.Count)];
                Transfer(Selecter,UkolZadavatel,0,UkolZadavatel.Count-1);
                CtiPopis:=True;
             end;
         end;

         if CtiPopis then
            begin
             if SubSelPopis=nil then
              begin
                SubSelPopis:=TKvaSelecter.Create(self);;
                SubSelPopis.Database:=FConnect.DbUsr;
                SubSelPopis.Sloupce:='inpppc,cisrad,texrad';
                SubSelPopis.Tabulka:='pprppp';
                SubSelPopis.OrderBy:='cisrad';
                SubSelPopis.Podminka:='inpppc=:inpppc';
              end;
              SubSelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
              SubSelPopis.OpenCursor;
              i:=0;
               while SubSelPopis.SQLError<>100 do
               begin
                  if UkolZadavatel<>nil then
                  begin
                     UkolZadavatel.FPopis.Radek[i]:=SubSelPopis.Fields[2].AsFullString;
                     i:=i+1;         //standartní řešení Kvasaru
                  end;
                  SubSelPopis.Fetch;
               end;
               SubSelPopis.CloseCursor;
            end;
         CtiPopis:=False;
         Selecter.Fetch;
       end;
     Selecter.CloseCursor;  //jako "zastupující" role
     if TypUzivatele=0 then
       for j:=0 to UkolZadavatelList.FPLoginList.Count-1 do
          begin
             LLogin:=UkolZadavatelList.FPLoginList.PLogin[j];
             for k:=0 to LLogin.PRole.Count-1 do
                begin
                   LRole:=LLogin.PRole.PRole[k];
                   Lincuzi:=UkolZadavatelList.UzivatelList.KodDleJmena(LRole.uzivat);
                   Selecter.Database:=FConnect.DbUsr;
                   Selecter.Sloupce:=UkolZadavatelList.Text;
                   Selecter.Tabulka:='pprppc';
                   Selecter.OrderBy:='datpln,stauko';
                   Selecter.Podminka:='kfirma=:kfirma and typuzi=:typuzi and zadava='+Lincuzi.ToString;
                   Selecter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
                   Selecter.Hodnoty.ParamByName('typuzi').AsInteger:=1;
                   Selecter.OpenCursor;
                   while Selecter.SQLError<>100 do
                     begin
                        Linpppc:=Selecter.Fields[0].AsInteger;
                        if not UkolZadavatelList.UkolExist(Linpppc) then
                        begin
                          case ReadType of
                             0:
                               begin
                                  Lstauko:=Selecter.Fields[9].AsInteger;
                                  Ldatpln:=Selecter.Fields[6].AsDateTime;
                                  if ((Lstauko in [1,2]) and (Ldatpln>=IncMonth(datref,-1))) or (Lstauko=0) then
                                    begin
                                      UkolZadavatel:=UkolZadavatelList.UkolZadavatel[UkolZadavatelList.InsertRow(UkolZadavatelList.Count)];
                                      Transfer(Selecter,UkolZadavatel,0,UkolZadavatel.Count-1);
                                      CtiPopis:=True;
                                    end;
                               end;
                             1:
                               begin
                                  UkolZadavatel:=UkolZadavatelList.UkolZadavatel[UkolZadavatelList.InsertRow(UkolZadavatelList.Count)];
                                  Transfer(Selecter,UkolZadavatel,0,UkolZadavatel.Count-1);
                                  CtiPopis:=True;
                               end;
                          end;

                         if CtiPopis then
                          begin
                           if SubSelPopis=nil then
                            begin
                              SubSelPopis:=TKvaSelecter.Create(self);;
                              SubSelPopis.Database:=FConnect.DbUsr;
                              SubSelPopis.Sloupce:='inpppc,cisrad,texrad';
                              SubSelPopis.Tabulka:='pprppp';
                              SubSelPopis.OrderBy:='cisrad';
                              SubSelPopis.Podminka:='inpppc=:inpppc';
                            end;
                            SubSelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
                            SubSelPopis.OpenCursor;
                            i:=0;
                             while SubSelPopis.SQLError<>100 do
                             begin
                                if UkolZadavatel<>nil then
                                begin
                                   UkolZadavatel.FPopis.Radek[i]:=SubSelPopis.Fields[2].AsFullString;
                                   i:=i+1;         //standartní řešení Kvasaru
                                end;
                                SubSelPopis.Fetch;
                             end;
                             SubSelPopis.CloseCursor;
                          end;
                         CtiPopis:=False;
                         Selecter.Fetch;
                        end;
                     end;
                   Selecter.CloseCursor;
                end;
          end;
     Selecter.Destroy;
     if SubSelPopis<>nil then SubSelPopis.Destroy;
     UkolZadavatelList.Save;
  except
    on E:Exception do
      begin
        FError:=Selecter.SQLError;
        raise;
      end;
  end;
end;

procedure TKvaUkolZadavatelListSQL.Write;
var i,j:Integer;
    UkolZadavatelList:TKvaUkolZadavatelList;
    UkolZadavatel:TkvaUkolZadavatel;
    Inserter:TKvaInserter;
    Deleter:TKvaDeleter;
    Updater:TKvaUpdater;
    MyTransaction:boolean;
    SubInsPopis:TKvaInserter;
    SubDelPopis:TKvaDeleter;
    SubUpdPopis:TKvaUpdater;
    pomstr:String;
    LPomSub:Smallint;
    PomUzivatel:TKvaUzivatel;

procedure CreateSubPopis(Index:Integer);
 begin
   case Index of
     0:begin
         SubInsPopis:=TKvaInserter.Create(self);
         SubInsPopis.Database:=FConnect.DbUsr;
         SubInsPopis.Tabulka:='pprppp';
         SubInsPopis.Sloupce:='inpppc,cisrad,texrad';
        end;
     1:begin
         SubUpdPopis:=TKvaUpdater.Create(self);
         SubUpdPopis.Database:=FConnect.DbUsr;
         SubUpdPopis.Tabulka:='pprppp';
       end;
     2:begin
         SubDelPopis:=TKvaDeleter.Create(self);
         SubDelPopis.Database:=FConnect.DbUsr;
         SubDelPopis.Tabulka:='pprppp';
       end;
   end;
 end;

begin
   FError:=0;
   Inserter:=nil;
   Deleter:=nil;
   UpDater:=nil;
   SubInsPopis:=nil;
   SubDelPopis:=nil;
   SubUpdPopis:=nil;
   UkolZadavatelList:=TKvaUkolZadavatelList(Owner);
   if FConnect.DbUsr.InTransaction then
      MyTransaction:=False
   else
   begin
      MyTransaction:=True;
      if MyTransaction then
      FConnect.DbUsr.StartTransaction;
   end;
   try
      for i:=0 to UkolZadavatelList.Count-1 do
      begin
         UkolZadavatel:=UkolZadavatelList.UkolZadavatel[i];
         case UkolZadavatel.Status of
         rsInsert:
         try
            LPomSub:=1;
            if UkolZadavatel.stauko=1 then
            begin
               if UkolZadavatel.typuzi=1 then
               begin
                  PomUzivatel:=UkolZadavatelList.UzivatelList.UzivatelDleKodu(UkolZadavatel.odposa);
                  if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                  begin
                     UkolZadavatel.typuzi:=0;
                     UkolZadavatel.odposa:=PomUzivatel.incipr;
                  end;
               end;
               if UkolZadavatel.typzad=1 then
               begin
                  PomUzivatel:=UkolZadavatelList.UzivatelList.UzivatelDleKodu(UkolZadavatel.zadava);
                  if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                  begin
                     UkolZadavatel.typzad:=0;
                     UkolZadavatel.zadava:=PomUzivatel.incipr;
                  end
                  else if FMasterKey>0 then
                  begin
                     UkolZadavatel.typzad:=0;
                     UkolZadavatel.zadava:=FMasterKey;
                  end
               end;
            end;
            if Inserter=nil then
            begin
               Inserter:=TKvaInserter.Create(self);
               Inserter.Database:=FConnect.DbUsr;
               Inserter.Tabulka:='pprppc';
               Inserter.Sloupce:=UkolZadavatel.Text;
               Inserter.Klic:='inpppc';
            end;
            Inserter.Hodnoty.ParamByName('inpppc').AsInteger:=0;
            Transfer(Inserter,UkolZadavatel,1,UkolZadavatel.Count-1);
            Inserter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
            Inserter.Insert;
            UkolZadavatel.ItemByName('inpppc').AsInteger:=Inserter.Serial;
            if SubInsPopis=nil then
            begin
               CreateSubPopis(0);
            end;
            for j:=0 to UkolZadavatel.Popis.Pocet-1 do
            begin
               LPomSub:=2;
               pomstr:=UkolZadavatel.Popis.Radek[j];
               SubInsPopis.Hodnoty.ParamByName('cisrad').AsInteger:=j;
               SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
               SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=pomstr;
               SubInsPopis.Insert;
            end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Inserter.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsUpdate:
         try
            if UkolZadavatel.TextChange<>'' then
              begin
                LPomSub:=1;
                if UkolZadavatel.stauko=1 then
                begin
                   if UkolZadavatel.typuzi=1 then
                   begin
                      PomUzivatel:=UkolZadavatelList.UzivatelList.UzivatelDleKodu(UkolZadavatel.odposa);
                      if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                      begin
                         UkolZadavatel.typuzi:=0;
                         UkolZadavatel.odposa:=PomUzivatel.incipr;
                      end;
                   end;
                   if UkolZadavatel.typzad=1 then
                   begin
                      PomUzivatel:=UkolZadavatelList.UzivatelList.UzivatelDleKodu(UkolZadavatel.zadava);
                      if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                      begin
                         UkolZadavatel.typzad:=0;
                         UkolZadavatel.zadava:=PomUzivatel.incipr;
                      end
                      else if FMasterKey>0 then
                      begin
                         UkolZadavatel.typzad:=0;
                         UkolZadavatel.zadava:=FMasterKey;
                      end
                   end;
                end;
                if Updater=nil then
                begin
                   Updater:=TKvaUpdater.Create(self);
                   Updater.Database:=FConnect.DbUsr;
                   Updater.Tabulka:='pprppc';
                end;
                Updater.Sloupce:=UkolZadavatel.TextChange;
                Updater.Podminka:='inpppc=:inpppc';
                Updater.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
                Transfer(UpDater,UkolZadavatel,0,UkolZadavatel.Count-1);
                Updater.Update;
              end;
            if UkolZadavatel.Popis.Change then
             begin
                if SubDelPopis=nil then
                   CreateSubPopis(2);
                SubDelPopis.Podminka:='inpppc=:inpppc';
                SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
                SubDelPopis.Delete;
                for j:=0 to UkolZadavatel.Popis.Pocet-1 do
                begin
                   LPomSub:=2;
                   if SubInsPopis=nil then
                      CreateSubPopis(0);
                   SubInsPopis.Hodnoty.ParamByName('cisrad').AsSmallint:=j;
                   SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=UkolZadavatel.Popis.Radek[j];
                   SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
                   SubInsPopis.Insert;
                end;
             end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Updater.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsDelete:
         try
            LPomSub:=1;
            if Deleter=nil then
            begin
               Deleter:=TKvaDeleter.Create(self);
               Deleter.Database:=FConnect.DbUsr;
               Deleter.Tabulka:='pprppc';
            end;
            Deleter.Podminka:='inpppc=:inpppc';
            Deleter.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
            Deleter.Delete;
            if SubDelPopis=nil then CreateSubPopis(2);
            LPomSub:=2;
            SubDelPopis.Podminka:='inpppc=:inpppc';
            SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolZadavatel.inpppc;
            SubDelPopis.Delete;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Deleter.SQLError;
               if LPomSub=2 then  FError:=SubDelPopis.SQLError;
               raise;
            end;
         end;
         end;
      end;
   finally
      if Inserter<>nil then
      Inserter.Destroy;
      if Updater<>nil then
      Updater.Destroy;
      if Deleter<>nil then
      Deleter.Destroy;
      if SubInsPopis<>nil then SubInsPopis.Destroy;
      if SubDelPopis<>nil then SubDelPopis.Destroy;
      if SubUpdPopis<>nil then SubUpdPopis.Destroy;
      if MyTransaction then
      begin
         if FError=0 then
         begin
            FConnect.DbUsr.Commit;
            UkolZadavatelList.Save;
         end else
           FConnect.DbUsr.Rollback;
      end;
   end;
end;

(* TKvaUkolOdpovednaOs *)

constructor TKvaUkolOdpovednaOs.Create(AOwner:TComponent);
begin
  inherited;
end;

(* TKvaUkolOdpovednaOsList *)

procedure TKvaUkolOdpovednaOsList.Clear;
begin
  inherited;
end;

constructor TKvaUkolOdpovednaOsList.Create(AOwner:TComponent);
begin
  inherited;
  FSQL:=TKvaUkolOdpovednaOsListSQL.Create(self);
end;

destructor TKvaUkolOdpovednaOsList.Destroy;
begin
  FSQL.Destroy;
  inherited
end;

function TKvaUkolOdpovednaOsList.CreateElement:TKvaColumnList;
begin
  Result:=TKvaUkolOdpovednaOs.Create(self);
end;

function TKvaUkolOdpovednaOsList.GetUkolOdpovednaOs(Index:Integer):TKvaUkolOdpovednaOs;
begin
  Result:=TKvaUkolOdpovednaOs(GetRow(Index));
end;

function TKvaUkolOdpovednaOsList.InsertRow(Index:Integer):Integer;
begin
  Result:=inherited InsertRow(Index);
end;

procedure TKvaUkolOdpovednaOsList.DeleteRow(Index:Integer);
begin
  inherited;
end;

function TKvaUkolOdpovednaOsList.UkolDleKodu(inpppc:Integer):TKvaUkolOdpovednaOs;
var PomUkol:TKvaUkolOdpovednaOs;
    i:Integer;
begin
  Result:=nil;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolOdpovednaOs[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=PomUkol;
       Break;
     end;
  end;
end;

function TKvaUkolOdpovednaOsList.UkolExist(inpppc:Integer):Boolean;
var PomUkol:TKvaUkolOdpovednaOs;
    i:Integer;
begin
  Result:=False;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolOdpovednaOs[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=True;
       Break;
     end;
  end;
end;

function TKvaUkolOdpovednaOsList.IndexDleKodu(inpppc:Integer):Integer;
var PomUkol:TKvaUkolOdpovednaOs;
    i:Integer;
begin
  Result:=-1;
  for i:=0 to NumRows-1 do
  begin
     PomUkol:=UkolOdpovednaOs[i];
     if PomUkol.inpppc=inpppc then
     begin
       Result:=i;
       Break;
     end;
  end;
end;


(* TKvaUkolOdpovednaOsListSQL *)
procedure TKvaUkolOdpovednaOsListSQL.Read;
var Selecter:TKvaSelecter;
    SubSelPopis:TKvaSelecter;
    UkolOdpovednaOs:TKvaUkolOdpovednaOs;
    UkolOdpovednaOsList:TKvaUkolOdpovednaOsList;
    i,j,k,Lincuzi,Linpppc:Integer;
    CtiPopis:Boolean;
    Lstauko:Smallint;
    Ldatpln:TDateTime;
    LLogin:TKvaPLogin;
    LRole:TKvaPRole;
begin
  FError:=0;
  UkolOdpovednaOsList:=TKvaUkolOdpovednaOsList(Owner);
  UkolOdpovednaOsList.Clear;
  SubSelPopis:=nil;
  CtiPopis:=False;
  Selecter:=TKvaSelecter.Create(self);
  try
     Selecter.Database:=FConnect.DbUsr;
     Selecter.Sloupce:=UkolOdpovednaOsList.Text;
     Selecter.Tabulka:='pprppc';
     Selecter.OrderBy:='datpln,stauko';
     Selecter.Podminka:='kfirma=:kfirma and odposa=:inckey and typuzi=:typuzi';
     Selecter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
     Selecter.Hodnoty.ParamByName('inckey').AsInteger:=FMasterKey;
     Selecter.Hodnoty.ParamByName('typuzi').AsInteger:=TypUzivatele;
     Selecter.OpenCursor;
     while Selecter.SQLError<>100 do
       begin
         case ReadType of
           0:
             begin
                Lstauko:=Selecter.Fields[9].AsInteger;
                Ldatpln:=Selecter.Fields[6].AsDateTime;
                if ((Lstauko in [1,2]) and (Ldatpln>=IncMonth(datref,-1))) or (Lstauko=0) then
                  begin
                    UkolOdpovednaOs:=UkolOdpovednaOsList.UkolOdpovednaOs[UkolOdpovednaOsList.InsertRow(UkolOdpovednaOsList.Count)];
                    Transfer(Selecter,UkolOdpovednaOs,0,UkolOdpovednaOs.Count-1);
                    CtiPopis:=True;
                  end;
             end;
           1:
             begin
                UkolOdpovednaOs:=UkolOdpovednaOsList.UkolOdpovednaOs[UkolOdpovednaOsList.InsertRow(UkolOdpovednaOsList.Count)];
                Transfer(Selecter,UkolOdpovednaOs,0,UkolOdpovednaOs.Count-1);
                CtiPopis:=True;
             end;
         end;

         if CtiPopis then
            begin
             if SubSelPopis=nil then
              begin
                SubSelPopis:=TKvaSelecter.Create(self);;
                SubSelPopis.Database:=FConnect.DbUsr;
                SubSelPopis.Sloupce:='inpppc,cisrad,texrad';
                SubSelPopis.Tabulka:='pprppp';
                SubSelPopis.OrderBy:='cisrad';
                SubSelPopis.Podminka:='inpppc=:inpppc';
              end;
              SubSelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
              SubSelPopis.OpenCursor;
              i:=0;
               while SubSelPopis.SQLError<>100 do
               begin
                  if UkolOdpovednaOs<>nil then
                  begin
                     UkolOdpovednaOs.FPopis.Radek[i]:=SubSelPopis.Fields[2].AsFullString;
                     i:=i+1;         //standartní řešení Kvasaru
                  end;
                  SubSelPopis.Fetch;
               end;
               SubSelPopis.CloseCursor;
            end;
         CtiPopis:=False;
         Selecter.Fetch;
       end;
     Selecter.CloseCursor;
     for j:=0 to UkolOdpovednaOsList.FPLoginList.Count-1 do
        begin
           LLogin:=UkolOdpovednaOsList.FPLoginList.PLogin[j];
           for k:=0 to LLogin.PRole.Count-1 do
              begin
                 LRole:=LLogin.PRole.PRole[k];
                 Lincuzi:=UkolOdpovednaOsList.UzivatelList.KodDleJmena(LRole.uzivat);
                 Selecter.Database:=FConnect.DbUsr;
                 Selecter.Sloupce:=UkolOdpovednaOsList.Text;
                 Selecter.Tabulka:='pprppc';
                 Selecter.OrderBy:='datpln,stauko';
                 Selecter.Podminka:='kfirma=:kfirma and typuzi=:typuzi and odposa='+Lincuzi.ToString;
                 Selecter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
                 Selecter.Hodnoty.ParamByName('typuzi').AsInteger:=1;
                 Selecter.OpenCursor;
                 while Selecter.SQLError<>100 do
                   begin
                      Linpppc:=Selecter.Fields[0].AsInteger;
                      if not UkolOdpovednaOsList.UkolExist(Linpppc) then
                      begin
                        case ReadType of
                           0:
                             begin
                                Lstauko:=Selecter.Fields[9].AsInteger;
                                Ldatpln:=Selecter.Fields[6].AsDateTime;
                                if ((Lstauko in [1,2]) and (Ldatpln>=IncMonth(datref,-1))) or (Lstauko=0) then
                                  begin
                                    UkolOdpovednaOs:=UkolOdpovednaOsList.UkolOdpovednaOs[UkolOdpovednaOsList.InsertRow(UkolOdpovednaOsList.Count)];
                                    Transfer(Selecter,UkolOdpovednaOs,0,UkolOdpovednaOs.Count-1);
                                    CtiPopis:=True;
                                  end;
                             end;
                           1:
                             begin
                                UkolOdpovednaOs:=UkolOdpovednaOsList.UkolOdpovednaOs[UkolOdpovednaOsList.InsertRow(UkolOdpovednaOsList.Count)];
                                Transfer(Selecter,UkolOdpovednaOs,0,UkolOdpovednaOs.Count-1);
                                CtiPopis:=True;
                             end;
                        end;

                       if CtiPopis then
                          begin
                           if SubSelPopis=nil then
                            begin
                              SubSelPopis:=TKvaSelecter.Create(self);;
                              SubSelPopis.Database:=FConnect.DbUsr;
                              SubSelPopis.Sloupce:='inpppc,cisrad,texrad';
                              SubSelPopis.Tabulka:='pprppp';
                              SubSelPopis.OrderBy:='cisrad';
                              SubSelPopis.Podminka:='inpppc=:inpppc';
                            end;
                            SubSelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
                            SubSelPopis.OpenCursor;
                            i:=0;
                             while SubSelPopis.SQLError<>100 do
                             begin
                                if UkolOdpovednaOs<>nil then
                                begin
                                   UkolOdpovednaOs.FPopis.Radek[i]:=SubSelPopis.Fields[2].AsFullString;
                                   i:=i+1;         //standartní řešení Kvasaru
                                end;
                                SubSelPopis.Fetch;
                             end;
                             SubSelPopis.CloseCursor;
                          end;
                       CtiPopis:=False;
                      end;
                      Selecter.Fetch;
                   end;
                 Selecter.CloseCursor;
              end;
        end;
     Selecter.Destroy;
     if SubSelPopis<>nil then SubSelPopis.Destroy;
     UkolOdpovednaOsList.Save;
  except
    on E:Exception do
      begin
        FError:=Selecter.SQLError;
        raise;
      end;
  end;
end;

procedure TKvaUkolOdpovednaOsListSQL.Write;
var i,j:Integer;
    UkolOdpovednaOsList:TKvaUkolOdpovednaOsList;
    UkolOdpovednaOs:TkvaUkolOdpovednaOs;
    Inserter:TKvaInserter;
    Deleter:TKvaDeleter;
    Updater:TKvaUpdater;
    MyTransaction:boolean;
    SubInsPopis:TKvaInserter;
    SubDelPopis:TKvaDeleter;
    SubUpdPopis:TKvaUpdater;
    pomstr:String;
    LPomSub:Smallint;
    PomUzivatel:TKvaUzivatel;

procedure CreateSubPopis(Index:Integer);
 begin
   case Index of
     0:begin
         SubInsPopis:=TKvaInserter.Create(self);
         SubInsPopis.Database:=FConnect.DbUsr;
         SubInsPopis.Tabulka:='pprppp';
         SubInsPopis.Sloupce:='inpppc,cisrad,texrad';
        end;
     1:begin
         SubUpdPopis:=TKvaUpdater.Create(self);
         SubUpdPopis.Database:=FConnect.DbUsr;
         SubUpdPopis.Tabulka:='pprppp';
       end;
     2:begin
         SubDelPopis:=TKvaDeleter.Create(self);
         SubDelPopis.Database:=FConnect.DbUsr;
         SubDelPopis.Tabulka:='pprppp';
       end;
   end;
 end;

begin
   FError:=0;
   Inserter:=nil;
   Deleter:=nil;
   UpDater:=nil;
   SubInsPopis:=nil;
   SubDelPopis:=nil;
   SubUpdPopis:=nil;
   UkolOdpovednaOsList:=TKvaUkolOdpovednaOsList(Owner);
   if FConnect.DbUsr.InTransaction then
      MyTransaction:=False
   else
   begin
      MyTransaction:=True;
      if MyTransaction then
      FConnect.DbUsr.StartTransaction;
   end;
   try
      for i:=0 to UkolOdpovednaOsList.Count-1 do
      begin
         UkolOdpovednaOs:=UkolOdpovednaOsList.UkolOdpovednaOs[i];
         case UkolOdpovednaOs.Status of
         rsInsert:
         try
            LPomSub:=1;
            if UkolOdpovednaOs.stauko=1 then
            begin
               if UkolOdpovednaOs.typuzi=1 then
               begin
                  PomUzivatel:=UkolOdpovednaOsList.UzivatelList.UzivatelDleKodu(UkolOdpovednaOs.odposa);
                  if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                  begin
                     UkolOdpovednaOs.typuzi:=0;
                     UkolOdpovednaOs.odposa:=PomUzivatel.incipr;
                  end
                  else if FMasterKey>0 then
                  begin
                     UkolOdpovednaOs.typuzi:=0;
                     UkolOdpovednaOs.odposa:=FMasterKey;
                  end
               end;
               if UkolOdpovednaOs.typzad=1 then
               begin
                  PomUzivatel:=UkolOdpovednaOsList.UzivatelList.UzivatelDleKodu(UkolOdpovednaOs.zadava);
                  if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                  begin
                     UkolOdpovednaOs.typzad:=0;
                     UkolOdpovednaOs.zadava:=PomUzivatel.incipr;
                  end;
               end;
            end;
            if Inserter=nil then
            begin
               Inserter:=TKvaInserter.Create(self);
               Inserter.Database:=FConnect.DbUsr;
               Inserter.Tabulka:='pprppc';
               Inserter.Sloupce:=UkolOdpovednaOs.Text;
               Inserter.Klic:='inpppc';
            end;
            Inserter.Hodnoty.ParamByName('inpppc').AsInteger:=0;
            Transfer(Inserter,UkolOdpovednaOs,1,UkolOdpovednaOs.Count-1);
            Inserter.Hodnoty.ParamByName('kfirma').AsSmallint:=FCompanyKey;
            Inserter.Insert;
            UkolOdpovednaOs.ItemByName('inpppc').AsInteger:=Inserter.Serial;
            if SubInsPopis=nil then
            begin
               CreateSubPopis(0);
            end;
            for j:=0 to UkolOdpovednaOs.Popis.Pocet-1 do
            begin
               LPomSub:=2;
               pomstr:=UkolOdpovednaOs.Popis.Radek[j];
               SubInsPopis.Hodnoty.ParamByName('cisrad').AsInteger:=j;
               SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
               SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=pomstr;
               SubInsPopis.Insert;
            end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Inserter.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsUpdate:
         try
          if UkolOdpovednaOs.TextChange<>'' then
            begin
              LPomSub:=1;
              if UkolOdpovednaOs.stauko=1 then
               begin
                 if UkolOdpovednaOs.typuzi=1 then
                  begin
                    PomUzivatel:=UkolOdpovednaOsList.UzivatelList.UzivatelDleKodu(UkolOdpovednaOs.odposa);
                    if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                    begin
                       UkolOdpovednaOs.typuzi:=0;
                       UkolOdpovednaOs.odposa:=PomUzivatel.incipr;
                    end
                    else if FMasterKey>0 then
                    begin
                       UkolOdpovednaOs.typuzi:=0;
                       UkolOdpovednaOs.odposa:=FMasterKey;
                    end
                  end;
                 if UkolOdpovednaOs.typzad=1 then
                  begin
                    PomUzivatel:=UkolOdpovednaOsList.UzivatelList.UzivatelDleKodu(UkolOdpovednaOs.zadava);
                    if (PomUzivatel<>nil) and (PomUzivatel.incipr>0) then
                    begin
                       UkolOdpovednaOs.typzad:=0;
                       UkolOdpovednaOs.zadava:=PomUzivatel.incipr;
                    end;
                  end;
               end;
              if Updater=nil then
               begin
                 Updater:=TKvaUpdater.Create(self);
                 Updater.Database:=FConnect.DbUsr;
                 Updater.Tabulka:='pprppc';
               end;
              Updater.Sloupce:=UkolOdpovednaOs.TextChange;
              Updater.Podminka:='inpppc=:inpppc';
              Updater.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
              Transfer(UpDater,UkolOdpovednaOs,0,UkolOdpovednaOs.Count-1);
              Updater.Update;
            end;
          if UkolOdpovednaOs.Popis.Change then
            begin
              if SubDelPopis=nil then
                 CreateSubPopis(2);
              SubDelPopis.Podminka:='inpppc=:inpppc';
              SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
              SubDelPopis.Delete;
              for j:=0 to UkolOdpovednaOs.Popis.Pocet-1 do
               begin
                 LPomSub:=2;
                 if SubInsPopis=nil then
                    CreateSubPopis(0);
                 SubInsPopis.Hodnoty.ParamByName('cisrad').AsSmallint:=j;
                 SubInsPopis.Hodnoty.ParamByName('texrad').AsString:=UkolOdpovednaOs.Popis.Radek[j];
                 SubInsPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
                 SubInsPopis.Insert;
               end;
            end;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Updater.SQLError;
               if LPomSub=2 then  FError:=SubInsPopis.SQLError;
               raise;
            end;
         end;
         rsDelete:
         try
            LPomSub:=1;
            if Deleter=nil then
            begin
               Deleter:=TKvaDeleter.Create(self);
               Deleter.Database:=FConnect.DbUsr;
               Deleter.Tabulka:='pprppc';
            end;
            Deleter.Podminka:='inpppc=:inpppc';
            Deleter.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
            Deleter.Delete;
            if SubDelPopis=nil then CreateSubPopis(2);
            LPomSub:=2;
            SubDelPopis.Podminka:='inpppc=:inpppc';
            SubDelPopis.Hodnoty.ParamByName('inpppc').AsInteger:=UkolOdpovednaOs.inpppc;
            SubDelPopis.Delete;
         except
            on E:Exception do
            begin
               if LPomSub=1 then  FError:=Deleter.SQLError;
               if LPomSub=2 then  FError:=SubDelPopis.SQLError;
               raise;
            end;
         end;
         end;
      end;
   finally
      if Inserter<>nil then
      Inserter.Destroy;
      if Updater<>nil then
      Updater.Destroy;
      if Deleter<>nil then
      Deleter.Destroy;
      if SubInsPopis<>nil then SubInsPopis.Destroy;
      if SubDelPopis<>nil then SubDelPopis.Destroy;
      if SubUpdPopis<>nil then SubUpdPopis.Destroy;
      if MyTransaction then
      begin
         if FError=0 then
         begin
            FConnect.DbUsr.Commit;
            UkolOdpovednaOsList.Save;
         end else
           FConnect.DbUsr.Rollback;
      end;
   end;
end;

end.
