Measure/DataModules/LeafXmjGlDm.pas

unit LeafXmjGlDm;

interface

uses
  SysUtils, Classes, ADODB, sdDB, sdProvider, mDataRecord;

type
  TLeafXmjGlData = class(TDataModule)
    sdpLeafXmjGL: TsdADOProvider;
    sddLeafXmjGL: TsdDataSet;
    sdvLeafXmjGL: TsdDataView;
    smpLeafXmj: TsdMemoryProvider;
    sddLeafXmj: TsdDataSet;
    sdvLeafXmj: TsdDataView;
    procedure sdvLeafXmjCurrentChanged(ARecord: TsdDataRecord);
    procedure sddLeafXmjGLGetRecordClass(var ARecordClass: TsdRecordClass);
  private
    FProjectData: TObject;

    function GetNewLeafXmjGlID: Integer;
  public
    constructor Create(AProjectData: TObject);
    destructor Destroy; override;

    procedure Open(AConnetion: TADOConnection);
    procedure Save;

    procedure RefreshLeafXmj;

    procedure ResetPhaseStageLink;
    procedure ResetRecordLink;

    procedure CalclateRec(ARec: TsdDataRecord);
    procedure CalculateLeafXmjGL(AXmjID, AGLID: Integer);
    procedure CalculateLeafXmj(AXmjID: Integer);
    procedure CalcluateGL(AGLID: Integer);

    function LeafXmjGLRec(AXmjID, AGLID: Integer): TLeafXmjGlRecord;

    procedure LoadLeafXmjGLs(AGLID: Integer; vGLs: TList);

    function AddLeafXmjGl(AXmjID, AGLID: Integer): TLeafXmjGlRecord;
    procedure DeleteLeafXmjGl(AXmjID, AGLID: Integer);
  end;

implementation

uses
  ProjectData, BillsCompileDm, BillsTree, sdIDTree, GclBillsGatherModel,
  UtilMethods, PhaseData, StageLeafXmjGlDm, Variants;

{$R *.dfm}

{ TLeafXmjGlData }

function TLeafXmjGlData.AddLeafXmjGl(AXmjID,
  AGLID: Integer): TLeafXmjGlRecord;
begin
  Result := TLeafXmjGlRecord(sddLeafXmjGL.FindKey('idxView', VarArrayOf([AXmjID, AGLID])));
  if not Assigned(Result) then
  begin
    //Result := TLeafXmjGlRecord(sddLeafXmjGL.Add(True));
    Result := TLeafXmjGlRecord(sddLeafXmjGL.Add);
    Result.ID.AsInteger := GetNewLeafXmjGlID;
    Result.XmjID.AsInteger := AXmjID;
    Result.GLID.AsInteger := AGLID;
    //Result.EndUpdate;
    with TProjectData(FProjectData).PhaseData.StageLeafXmjGlData do
      Result.StageRec := StageLeafXmjGlRecord(Result.ID.AsInteger);
  end;
end;

procedure TLeafXmjGlData.CalclateRec(ARec: TsdDataRecord);
begin
  with TProjectData(FProjectData).PhaseData do
    if Assigned(ARec) and Active then
      StageLeafXmjGlData.Calculate(ARec.ValueByName('ID').AsInteger);
end;

procedure TLeafXmjGlData.CalcluateGL(AGLID: Integer);
var
  idx: TsdIndex;
  iRec, iFirst, iLast: Integer;
  Rec: TsdDataRecord;
begin
  idx := sddLeafXmjGL.FindIndex('idxGl');
  iFirst := idx.FindKeyIndex(AGLID);
  iLast := idx.FindKeyLastIndex(AGLID);
  if iFirst = -1 then Exit;
  for iRec := iFirst to iLast do
  begin
    Rec := idx.Records[iRec];
    CalclateRec(Rec);
  end;
end;

procedure TLeafXmjGlData.CalculateLeafXmj(AXmjID: Integer);
var
  idx: TsdIndex;
  iRec, iFirst, iLast: Integer;
  Rec: TsdDataRecord;
begin
  idx := sddLeafXmjGL.FindIndex('idxXmj');
  iFirst := idx.FindKeyIndex(AXmjID);
  iLast := idx.FindKeyLastIndex(AXmjID);
  if iFirst = -1 then Exit;
  for iRec := iFirst to iLast do
  begin
    Rec := idx.Records[iRec];
    CalclateRec(Rec);
  end;
end;

procedure TLeafXmjGlData.CalculateLeafXmjGL(AXmjID, AGLID: Integer);
var
  Rec: TsdDataRecord;
begin
  Rec := sddLeafXmjGL.FindKey('idxView', VarArrayOf([AXmjID, AGLID]));
  CalclateRec(Rec);
end;

constructor TLeafXmjGlData.Create(AProjectData: TObject);
begin
  inherited Create(nil);
  FProjectData := AProjectData;

  sdvLeafXmjGL.Columns.FindColumn('Code').LookupDataSet := TProjectData(FProjectData).ProjectGLData.sddProjectGL;
  sdvLeafXmjGL.Columns.FindColumn('Name').LookupDataSet := TProjectData(FProjectData).ProjectGLData.sddProjectGL;
  sdvLeafXmjGL.Columns.FindColumn('Units').LookupDataSet := TProjectData(FProjectData).ProjectGLData.sddProjectGL;
  sdvLeafXmjGL.Columns.FindColumn('Specs').LookupDataSet := TProjectData(FProjectData).ProjectGLData.sddProjectGL;
end;

procedure TLeafXmjGlData.DeleteLeafXmjGl(AXmjID, AGLID: Integer);
var
  Rec: TsdDataRecord;
begin
  Rec := sddLeafXmjGL.FindKey('idxView', VarArrayOf([AXmjID, AGLID]));
  if Assigned(Rec) then
  begin
    with TProjectData(FProjectData).PhaseData do
      StageLeafXmjGlData.DeleteLeafXmjGLRecord(Rec.ValueByName('ID').AsInteger);
    sddLeafXmjGL.Remove(Rec);
  end;
end;

destructor TLeafXmjGlData.Destroy;
begin
  inherited;
end;

function TLeafXmjGlData.GetNewLeafXmjGlID: Integer;
var
  vIdx: TsdIndex;
begin
  vIdx := sddLeafXmjGL.FindIndex('idxID');
  if vIdx.RecordCount > 0 then
    Result := vIdx.Records[vIdx.RecordCount - 1].ValueByName('ID').AsInteger + 1
  else
    Result := 0;
end;

procedure TLeafXmjGlData.Open(AConnetion: TADOConnection);
begin
  sddLeafXmj.Open;
  if not Assigned(sddLeafXmj.FindIndex('idxID')) then
    sddLeafXmj.AddIndex('idxID', 'ID');
  if not Assigned(sddLeafXmj.FindIndex('idxSerial')) then
    sddLeafXmj.AddIndex('idxSerial', 'SerialNo');
  sdvLeafXmj.Open;
  sdvLeafXmj.IndexName := 'idxSerial';

  sdpLeafXmjGL.Connection := AConnetion;
  sddLeafXmjGL.Open;
  if not Assigned(sddLeafXmjGL.FindIndex('idxID')) then
    sddLeafXmjGL.AddIndex('idxID', 'ID');
  if not Assigned(sddLeafXmjGL.FindIndex('idxView')) then
    sddLeafXmjGL.AddIndex('idxView', 'XmjID;GLID');
  if not Assigned(sddLeafXmjGL.FindIndex('idxXmj')) then
    sddLeafXmjGL.AddIndex('idxXmj', 'XmjID');
  if not Assigned(sddLeafXmjGL.FindIndex('idxGL')) then
    sddLeafXmjGL.AddIndex('idxGL', 'GLID');
  sdvLeafXmjGL.Open;
  sdvLeafXmjGL.IndexName := 'idxView';
end;

procedure TLeafXmjGlData.RefreshLeafXmj;

  function CheckLeafXmj(ANode: TBillsIDTreeNode): Boolean;
  var
    iChild: Integer;
    vChild: TBillsIDTreeNode;
  begin
    Result := False;
    if not Assigned(ANode) then Exit;
    if ANode.Rec.B_Code.AsString = '' then
    begin
      if ANode.HasChildren then
      begin
        for iChild := 0 to ANode.ChildCount - 1 do
        begin
          vChild := TBillsIDTreeNode(ANode.ChildNodes[iChild]);
          if vChild.Rec.B_Code.AsString <> '' then
          begin
            Result := True;
            Break;
          end;
        end;
      end
      else
        Result := False;
    end
    else
      Result := False;
  end;

  function GetPegNode(ANode: TBillsIDTreeNode): TBillsIDTreeNode;
  begin
    Result := nil;
    if not Assigned(ANode) then Exit;
    if CheckPeg(ANode.Rec.Name.AsString) then
      Result := ANode
    else
      Result := GetPegNode(TBillsIDTreeNode(ANode.Parent));
  end;

  procedure AddLeafXmj(ANode: TBillsIDTreeNode; ASerialNo: Integer);
  var
    Rec: TsdDataRecord;
    vPeg: TBillsIDTreeNode;
    vLeafXmj: TLeafXmjNode;
  begin
    vPeg := GetPegNode(ANode);
    vLeafXmj := TLeafXmjNode.Create(ANode, vPeg);
    try
      Rec := sddLeafXmj.Add;
      Rec.ValueByName('ID').AsInteger := ANode.ID;
      Rec.ValueByName('SerialNo').AsInteger := ASerialNo;
      Rec.ValueByName('Code').AsString := vLeafXmj.XmjCode;
      Rec.ValueByName('Name').AsString := vLeafXmj.XmjName;
      Rec.ValueByName('Units').AsString := vLeafXmj.XmjUnits;
      Rec.ValueByName('NameDanWei').AsString := vLeafXmj.NameDanWei;
      Rec.ValueByName('NameFenBu').AsString := vLeafXmj.NameFenBu;
      Rec.ValueByName('NameFenXiang').AsString := vLeafXmj.NameFenXiang;
      Rec.ValueByName('NameUnit').AsString := vLeafXmj.NameUnit;
      Rec.ValueByName('Peg').AsString := vLeafXmj.Peg;
      Rec.ValueByName('Position').AsString := vLeafXmj.Position;
      Rec.ValueByName('DrawingCode').AsString := vLeafXmj.DrawingCode;
    finally
      vLeafXmj.Free;
    end;
  end;

var
  iNode: Integer;
  vNode: TBillsIDTreeNode;
begin
  sddLeafXmj.BeginUpdate;
  sddLeafXmj.DisableControls;
  try
    sddLeafXmj.DeleteAll;
    with TProjectData(FProjectData).BillsCompileData do
    begin
      for iNode := 0 to BillsCompileTree.Count - 1 do
      begin
        vNode := TBillsIDTreeNode(BillsCompileTree.Items[iNode]);
        if CheckLeafXmj(vNode) then
          AddLeafXmj(vNode, iNode);
      end;
    end;
  finally
    sddLeafXmj.EnableControls;
    sddLeafXmj.EndUpdate;
  end;
end;

procedure TLeafXmjGlData.ResetPhaseStageLink;
begin
  with TProjectData(FProjectData).PhaseData do
  begin
    sdvLeafXmjGL.Columns.FindColumn('Quantity').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('UsedQuantity').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('PAL_UsedQuantity').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('PAL_UsedTotalPrice').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('PAL_DeltaPrice').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('PAL_Total').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('EndQuantity').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
    sdvLeafXmjGL.Columns.FindColumn('EndUsedQuantity').LookupDataSet := StageLeafXmjGlData.sddStageLeafXmjGl;
  end;
end;

procedure TLeafXmjGlData.ResetRecordLink;
var
  i: Integer;
  Rec: TLeafXmjGlRecord;
begin
  for i := 0 to sddLeafXmjGL.RecordCount - 1 do
  begin
    Rec := TLeafXmjGlRecord(sddLeafXmjGL.Records[i]);
    with TProjectData(FProjectData).PhaseData.StageLeafXmjGlData do
      Rec.StageRec := StageLeafXmjGlRecord(Rec.ID.AsInteger);
  end;
end;

procedure TLeafXmjGlData.Save;
begin
  sddLeafXmjGL.Save;
end;

procedure TLeafXmjGlData.sdvLeafXmjCurrentChanged(ARecord: TsdDataRecord);
begin
  if Assigned(ARecord) then
    sdvLeafXmjGL.SetRange([ARecord.ValueByName('ID').AsInteger], [ARecord.ValueByName('ID').AsInteger]);
end;

procedure TLeafXmjGlData.sddLeafXmjGLGetRecordClass(
  var ARecordClass: TsdRecordClass);
begin
  ARecordClass := TLeafXmjGlRecord;
end;

function TLeafXmjGlData.LeafXmjGLRec(AXmjID,
  AGLID: Integer): TLeafXmjGlRecord;
begin
  Result := TLeafXmjGlRecord(sddLeafXmjGL.FindKey('idxView', VarArrayOf([AXmjID, AGLID])));
end;

procedure TLeafXmjGlData.LoadLeafXmjGLs(AGLID: Integer; vGLs: TList);
var
  idx: TsdIndex;
  iRec, iFirst, iLast: Integer;
  Rec: TsdDataRecord;
begin
  idx := sddLeafXmjGL.FindIndex('idxGl');
  iFirst := idx.FindKeyIndex(AGLID);
  iLast := idx.FindKeyLastIndex(AGLID);
  if iFirst = -1 then Exit;
  for iRec := iFirst to iLast do
    vGLs.Add(idx.Records[iRec]);
end;

end.