Unit BPeaContainerUnit;

{$mode objfpc}{$H+}

Interface

Uses
  {$IFDEF TestCase}
    BMockQueryUnit,
  {$ELSE}
    BQueryUnit,
  {$ENDIF}
  sysutils, Classes, BCommonUnit, BListsUnit, BObjectUnit, BSQLUnit
//@UsesStart
  , BPeaValueUnit, BPeaValueHolderUnit
//@UsesStop
;

Type BPeaContainerClass = Class;

Type BPeaContainersList = Specialize BList<BPeaContainerClass>;
Type BPeaContainersThreadList = Specialize BThreadList<BPeaContainerClass>;
Type IPeaContainerInterface = Specialize IGenericInterface<BPeaContainerClass>;

Type

  { BPeaContainerClass }

  BPeaContainerClass = Class(BObjectClass, IPeaContainerInterface)
    Private
      //@PropertiesPrivateStart
      bCaption: String;
      bLink: BPeaValueClass;
      bHugePeaValues: BPeaValueHolderThreadList;
      bPeaValuesFirst: BPeaValuesThreadList;
      bPeaValuesLast: BPeaValuesThreadList;
      //@PropertiesPrivateStop
      //@PluralSavesDeclareStart
      Function SaveHugePeaValues(Const aQuery: BQueryClass): Boolean;
      Function SavePeaValuesFirst(Const aQuery: BQueryClass): Boolean;
      Function SavePeaValuesLast(Const aQuery: BQueryClass): Boolean;
      //@PluralSavesDeclareStop
      Procedure Load(Const aObject: BPeaContainerClass);
      Procedure InitializeObjects;
    Public
      //@PropertiesPublicStart
      Property Caption: String Read bCaption Write bCaption;
      Property Link: BPeaValueClass Read bLink Write bLink;
      Property HugePeaValues: BPeaValueHolderThreadList Read
        bHugePeaValues Write bHugePeaValues;
      Property PeaValuesFirst: BPeaValuesThreadList Read
        bPeaValuesFirst Write bPeaValuesFirst;
      Property PeaValuesLast: BPeaValuesThreadList Read
        bPeaValuesLast Write bPeaValuesLast;
      //@PropertiesPublicStop

      //@LoadPluralDeclareStart
      Procedure LoadHugePeaValues(Const aHugePeaValues: BPeaValueHolderList);
      Procedure LoadPeaValuesFirst(Const aPeaValuesFirst: BPeaValuesList);
      Procedure LoadPeaValuesLast(Const aPeaValuesLast: BPeaValuesList);
      //@LoadPluralDeclareStop

      //@AddGetRemovePluralDeclareStart
      //@AddGetRemovePluralDeclareStop

      Procedure Validate(Const aCommit: Boolean = FALSE);
      Function Save(Const aQuery: BQueryClass): Boolean;
      //@InitializeDeclareStart
      Procedure Initialize(Const aCaption: String; Const aLink:
        BPeaValueClass);
      //@InitializeDeclareStop
      Destructor Burn; Override;
End;

Type BPeaContainersManagerBlank = Specialize BManagerGeneric<BPeaContainerClass>;

Type

  { BPeaContainersManagerClass }

  BPeaContainersManagerClass = Class(BPeaContainersManagerBlank)
    Private
      bPeaContainers: BPeaContainersThreadList; Static;
      //@ManagerLoadPluralDeclareStart
      Procedure LoadHugePeaValues(Const aQuery: BQueryClass);
      Procedure LoadPeaValuesFirst(Const aQuery: BQueryClass);
      Procedure LoadPeaValuesLast(Const aQuery: BQueryClass);
      //@ManagerLoadPluralDeclareStop
    Public
      Procedure Load;
      Constructor Build;
      Destructor Burn; Override;
End;

Implementation

Const
  SQL_ID = 'ID';
  SQL_PRIOR = 'PRIOR';
  SQL_NEXT = 'NEXT';
  SQL_DELETED = 'DELETED';
  SQL_DELETED_NOT = 'DELETED = 0';
  SQL_ID_MATCH = 'ID = :ID';
  //@ConstStart
  SQL_NAME_MATCH = 'PEACONTAINER = :PEACONTAINER';
  SQL_NAME = 'PEACONTAINER';
  SQL_CAPTION = 'CAPTION';
  SQL_LINK = 'LINK';
  SQL_SOME_CAPTION = 'SOME_CAPTION';
  SQL_SOME_INT = 'SOME_INT';
  SQL_HUGE_PEA_VALUES = 'HUGE_PEA_VALUES';
  SQL_PEA_VALUE_FIRST = 'PEA_VALUE_FIRST';
  SQL_PEA_VALUE_LAST = 'PEA_VALUE_LAST';
  //@ConstStop

 { BPeaContainerClass }

Procedure BPeaContainerClass.Load(Const aObject: BPeaContainerClass);
Begin
  //@LoadStart
  Initialize( aObject.Caption, aObject.Link);
  HugePeaValues.Load(aObject.HugePeaValues.LockList);
  aObject.HugePeaValues.UnlockList;
  PeaValuesFirst.Load(aObject.PeaValuesFirst.LockList);
  aObject.PeaValuesFirst.UnlockList;
  PeaValuesLast.Load(aObject.PeaValuesLast.LockList);
  aObject.PeaValuesLast.UnlockList;
  //@LoadStop
End;

Procedure BPeaContainerClass.InitializeObjects;
Begin
  If Not(bInitialized) Then
    Begin
      //@InitializeObjectsStart
      bClassID := 110;
      bHugePeaValues := BPeaValueHolderThreadList.Build;
      bPeaValuesFirst := BPeaValuesThreadList.Build;
      bPeaValuesLast := BPeaValuesThreadList.Build;
      //@InitializeObjectsStop
      bInitialized := TRUE;
    End;
End;

//@LoadPluralStart

Procedure BPeaContainerClass.LoadHugePeaValues(Const aHugePeaValues:
  BPeaValueHolderList);
Begin
  bHugePeaValues.Clear;
  bHugePeaValues.Load(aHugePeaValues);
End;

Procedure BPeaContainerClass.LoadPeaValuesFirst(Const
  aPeaValuesFirst: BPeaValuesList);
Begin
  bPeaValuesFirst.Clear;
  bPeaValuesFirst.Load(aPeaValuesFirst);
End;

Procedure BPeaContainerClass.LoadPeaValuesLast(Const aPeaValuesLast:
  BPeaValuesList);
Begin
  bPeaValuesLast.Clear;
  bPeaValuesLast.Load(aPeaValuesLast);
End;
//@LoadPluralStop

//@AddGetRemovePluralStart
//@AddGetRemovePluralStop

Procedure BPeaContainerClass.Validate(Const aCommit: Boolean);
Begin
  Raise BExceptionClass.Build(1, 'Not specific validation terms');
End;

//@PluralSavesStart

Function BPeaContainerClass.SaveHugePeaValues(Const aQuery:
  BQueryClass): Boolean;
Var
  i: Integer;
  aSQL: BSQLClass;
  aList: BPeaValueHolderList;
Begin
  aSQL := BSQLClass.Build;
  aList := bHugePeaValues.LockList;
  Try
    aSQL.Builder.Delete(SQL_NAME + '_' + SQL_HUGE_PEA_VALUES).Where(
      SQL_NAME_MATCH);
    aSQL.AddParam(SQL_NAME, ID);
    Result := aQuery.Post(aSQL);

    For i := 0 To aList.Count - 1 Do
      Result := Result And aList[i].Save(ID, SQL_NAME + '_' +
        SQL_HUGE_PEA_VALUES, SQL_NAME, aQuery);
  Finally
    bHugePeaValues.UnlockList;
    aSQL.Burn;
  End;
End;

Function BPeaContainerClass.SavePeaValuesFirst(Const aQuery:
  BQueryClass): Boolean;
Var
  i: Integer;
  aSQL: BSQLClass;
  aList: BPeaValuesList;
  aPeaValuesManager: BPeaValuesManagerClass;
Begin
  aSQL := BSQLClass.Build;
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  aList := bPeaValuesFirst.LockList;
  Try
    aSQL.Builder.Delete(SQL_NAME + '_' + SQL_PEA_VALUE_FIRST).Where(
      SQL_NAME_MATCH);
    aSQL.AddParam(SQL_NAME, ID);
    Result := aQuery.Post(aSQL);

    aSQL.Clear;
    aSQL.Builder.Insert(SQL_NAME + '_' + SQL_PEA_VALUE_FIRST).
      AddParam(SQL_NAME).
      AddParam(SQL_PEA_VALUE_FIRST);
    aSQL.AddParam(SQL_NAME, ID);
    For i := 0 To aList.Count - 1 Do
      Begin
        aSQL.AddParam(SQL_PEA_VALUE_FIRST, aList[i].ID);
        Result := Result And aQuery.Post(aSQL);
      End;
  Finally
    bPeaValuesFirst.UnlockList;
    aPeaValuesManager.Burn;
    aSQL.Burn;
  End;
End;

Function BPeaContainerClass.SavePeaValuesLast(Const aQuery:
  BQueryClass): Boolean;
Var
  i: Integer;
  aSQL: BSQLClass;
  aList: BPeaValuesList;
  aPeaValuesManager: BPeaValuesManagerClass;
Begin
  aSQL := BSQLClass.Build;
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  aList := bPeaValuesLast.LockList;
  Try
    aSQL.Builder.Delete(SQL_NAME + '_' + SQL_PEA_VALUE_LAST).Where(
      SQL_NAME_MATCH);
    aSQL.AddParam(SQL_NAME, ID);
    Result := aQuery.Post(aSQL);

    aSQL.Clear;
    aSQL.Builder.Insert(SQL_NAME + '_' + SQL_PEA_VALUE_LAST).AddParam(
      SQL_NAME).
      AddParam(SQL_PEA_VALUE_LAST);
    aSQL.AddParam(SQL_NAME, ID);
    For i := 0 To aList.Count - 1 Do
      Begin
        aSQL.AddParam(SQL_PEA_VALUE_LAST, aList[i].ID);
        Result := Result And aQuery.Post(aSQL);
      End;
  Finally
    bPeaValuesLast.UnlockList;
    aPeaValuesManager.Burn;
    aSQL.Burn;
  End;
End;
//@PluralSavesStop

Function BPeaContainerClass.Save(Const aQuery: BQueryClass): Boolean;
Var
  i: Integer;
  aSQL: BSQLClass;
Begin
  Validate(TRUE);
  aSQL := BSQLClass.Build;
  Try
    //@SaveStart
    If ID < 0 Then
      aSQL.Builder.Insert(SQL_NAME).AddGenerator.AddParam(
        SQL_DELETED).AddParam(SQL_PRIOR).AddParam(SQL_NEXT).AddParam(
        SQL_CAPTION).AddParam(SQL_LINK).Returning(SQL_ID).Executable
    Else
      Begin
        aSQL.Builder.Update(SQL_NAME).AddParam(SQL_DELETED).AddParam(
          SQL_PRIOR).AddParam(SQL_NEXT).AddParam(SQL_CAPTION).
          AddParam(SQL_LINK).Where(SQL_ID_MATCH);
        aSQL.AddParam(SQL_ID, ID);
      End;

    aSQL.AddParam(SQL_DELETED, bDeleted);
    aSQL.AddParam(SQL_PRIOR, -1);
    aSQL.AddParam(SQL_NEXT, -1);
    aSQL.AddParam(SQL_CAPTION, Caption);
    If Not(Link = nil) Then aSQL.AddParam(SQL_LINK, Link.ID)
    Else aSQL.AddParam(SQL_LINK, -1);
    Result := aQuery.Post(aSQL);
    If Result And (ID < 0) Then bID := aQuery.ByInteger(SQL_ID);
    Result := Result And SaveHugePeaValues(aQuery);
    Result := Result And SavePeaValuesFirst(aQuery);
    Result := Result And SavePeaValuesLast(aQuery);
    //@SaveStop
  Finally
    aSQL.Burn;
  End;
End;

//@InitializeStart
Procedure BPeaContainerClass.Initialize(Const aCaption: String; Const
  aLink: BPeaValueClass);
Begin
  InitializeObjects;
  bCaption := aCaption;
  bLink := aLink;
  Validate;
End;
//@InitializeStop

Destructor BPeaContainerClass.Burn;
Begin
  //@BurnStart
  bHugePeaValues.Purge;
  bHugePeaValues.Burn;
  bPeaValuesFirst.Burn;
  bPeaValuesLast.Burn;
  //@BurnStop
End;

 { BPeaContainersManagerClass }

//@ManagerLoadPluralStart

Procedure BPeaContainersManagerClass.LoadHugePeaValues(Const aQuery:
  BQueryClass);
Var
  aSQL: BSQLClass;
  aPeaContainer: BPeaContainerClass;
  aPeaValueHolder: BPeaValueHolderClass;
  aPeaValue: BPeaValueClass;
  aPeaValuesManager: BPeaValuesManagerClass;
Begin
  aSQL := BSQLClass.Build;
  aSQL.Builder.Select(SQL_NAME + '_' + SQL_HUGE_PEA_VALUES).All;
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  Try;
    aQuery.Get(aSQL);
    While Not(aQuery.EOF) Do
      Begin
        aPeaContainer := GetObject(aQuery.ByInteger(SQL_NAME));
        aPeaValue := aPeaValuesManager.GetObject(aQuery.ByInteger(
          SQL_HUGE_PEA_VALUES));
        If Not((aPeaContainer = nil) Or (aPeaValue = nil)) Then
          Begin
            aPeaValueHolder := BPeaValueHolderClass.Build(aPeaValue);
            aPeaValueHolder.Load(aPeaContainer.ID, SQL_NAME + '_' +
              SQL_HUGE_PEA_VALUES, SQL_NAME, aQuery);
            aPeaContainer.bHugePeaValues.Add(aPeaValueHolder);
          End;
        aQuery.Next;
      End;
  Finally
    aPeaValuesManager.Burn;
    aSQL.Burn;
  End;
End;

Procedure BPeaContainersManagerClass.LoadPeaValuesFirst(Const aQuery:
  BQueryClass);
Var
  aSQL: BSQLClass;
  aPeaContainer: BPeaContainerClass;
  aPeaValue: BPeaValueClass;
  aPeaValuesManager: BPeaValuesManagerClass;
Begin
  aSQL := BSQLClass.Build;
  aSQL.Builder.Select(SQL_NAME + '_' + SQL_PEA_VALUE_FIRST).All;
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  Try;
    aQuery.Get(aSQL);
    While Not(aQuery.EOF) Do
      Begin
        aPeaContainer := GetObject(aQuery.ByInteger(SQL_NAME));
        aPeaValue := aPeaValuesManager.GetObject(aQuery.ByInteger(
          SQL_PEA_VALUE_FIRST));
        If Not((aPeaContainer = nil) Or (aPeaValue = nil)) Then
          aPeaContainer.bPeaValuesFirst.Add(aPeaValue);
        aQuery.Next;
      End;
  Finally
    aPeaValuesManager.Burn;
    aSQL.Burn;
  End;
End;

Procedure BPeaContainersManagerClass.LoadPeaValuesLast(Const aQuery:
  BQueryClass);
Var
  aSQL: BSQLClass;
  aPeaContainer: BPeaContainerClass;
  aPeaValue: BPeaValueClass;
  aPeaValuesManager: BPeaValuesManagerClass;
Begin
  aSQL := BSQLClass.Build;
  aSQL.Builder.Select(SQL_NAME + '_' + SQL_PEA_VALUE_LAST).All;
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  Try;
    aQuery.Get(aSQL);
    While Not(aQuery.EOF) Do
      Begin
        aPeaContainer := GetObject(aQuery.ByInteger(SQL_NAME));
        aPeaValue := aPeaValuesManager.GetObject(aQuery.ByInteger(
          SQL_PEA_VALUE_LAST));
        If Not((aPeaContainer = nil) Or (aPeaValue = nil)) Then
          aPeaContainer.bPeaValuesLast.Add(aPeaValue);
        aQuery.Next;
      End;
  Finally
    aPeaValuesManager.Burn;
    aSQL.Burn;
  End;
End;
//@ManagerLoadPluralStop

Procedure BPeaContainersManagerClass.Load;
Var
  aSQL: BSQLClass;
  aQuery: BQueryClass;
  //@ManagerLoadVarsStart
  aPeaValuesManager: BPeaValuesManagerClass;
  //@ManagerLoadVarsStop
Begin
  EnterState(msLoading);
  aSQL := BSQLClass.Build;
  aQuery := BQueryClass.Build(bDBIndex);
  //@ManagerLoadPrepareStart
  aPeaValuesManager := BPeaValuesManagerClass.Build;
  //@ManagerLoadPrepareStop
  Try
    aSQL.Builder.Select(SQL_NAME).All.
      Where(SQL_DELETED_NOT).OrderBy(SQL_ID);
    aQuery.Get(aSQL);
    While Not(aQuery.EOF) Do
      Begin
        //@ManagerLoadStart
        With aQuery Do
          AddObject(ByInteger(SQL_ID)).Initialize(ByString(
            SQL_CAPTION), aPeaValuesManager.GetObject(ByInteger(SQL_LINK)));
        //@ManagerLoadStop
        aQuery.Next;
      End;
    //@ManagerLoadPluralCallStart
    LoadHugePeaValues(aQuery);
    LoadPeaValuesFirst(aQuery);
    LoadPeaValuesLast(aQuery);
    //@ManagerLoadPluralCallStop
  Finally
    //@ManagerLoadFinalStart
    aPeaValuesManager.Burn;
    //@ManagerLoadFinalStop
    aQuery.Burn;
    aSQL.Burn;
    LeaveState;
  End;
End;

Constructor BPeaContainersManagerClass.Build;
Begin
  Inherited Build(bPeaContainers, 0, SQL_NAME);
End;

Destructor BPeaContainersManagerClass.Burn;
Begin
  Inherited Burn;
End;

Initialization
Begin
  BPeaContainersManagerClass.bPeaContainers := BPeaContainersThreadList.Build;
End;

Finalization
Begin
  BPeaContainersManagerClass.bPeaContainers.Purge;
  BPeaContainersManagerClass.bPeaContainers.Burn;
End;
End.