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);
    procedure sdvLeafXmjGLSetText(var Text: String; ARecord: TsdDataRecord;
      AValue: TsdValue; AColumn: TsdViewColumn; var Allow: Boolean);
    procedure sdvLeafXmjGLGetText(var Text: String; ARecord: TsdDataRecord;
      AValue: TsdValue; AColumn: TsdViewColumn; DisplayText: Boolean);
  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;

    function CheckWithoutUsedQuantity(AIndex: Integer): Boolean;

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

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

    property ProjectData: TObject read FProjectData;
  end;

implementation

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

{$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 CheckFilterLeafXmj(ANode: TBillsIDTreeNode): Boolean;

    function CheckExist: Boolean;
    begin
      Result := Assigned(sddLeafXmjGL.FindKey('idxXmj', ANode.ID));
    end;

    function CheckCur: Boolean;
    var
      vIdx: TsdIndex;
      iRec, iBegin, iEnd: Integer;
      Rec: TLeafXmjGlRecord;
      StageRec: TStageLeafXmjGlRecord;
    begin
      Result := False;
      vIdx := sddLeafXmjGL.FindIndex('idxXmj');
      iBegin := vIdx.FindKeyIndex(ANode.ID);
      iEnd := vIdx.FindKeyLastIndex(ANode.ID);
      if iBegin >= 0 then
      begin
        for iRec := iBegin to iEnd do
        begin
          Rec := TLeafXmjGlRecord(vIdx.Records[iRec]);
          StageRec := TStageLeafXmjGlRecord(Rec.StageRec);
          if Assigned(StageRec) and (StageRec.Quantity.AsFloat <> 0) then
          begin
            Result := True;
            Break;
          end;
        end;
      end;
    end;

    function CheckEnd: Boolean;
    var
      vIdx: TsdIndex;
      iRec, iBegin, iEnd: Integer;
      Rec: TLeafXmjGlRecord;
      StageRec: TStageLeafXmjGlRecord;
    begin
      Result := False;
      vIdx := sddLeafXmjGL.FindIndex('idxXmj');
      iBegin := vIdx.FindKeyIndex(ANode.ID);
      iEnd := vIdx.FindKeyLastIndex(ANode.ID);
      if iBegin >= 0 then
      begin
        for iRec := iBegin to iEnd do
        begin
          Rec := TLeafXmjGlRecord(vIdx.Records[iRec]);
          StageRec := TStageLeafXmjGlRecord(Rec.StageRec);
          if Assigned(StageRec) and (StageRec.EndQuantity.AsFloat <> 0) then
          begin
            Result := True;
            Break;
          end;
        end;
      end;
    end;

  begin
    case TProjectData(FProjectData).ProjProperties.LeafXmjGlFilterType of
      0: Result := CheckExist;
      1: Result := CheckCur;
      2: Result := CheckEnd;
    end;
  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;
  iBookMarkID: Integer;
begin
  if Assigned(sdvLeafXmj.Current) then
    iBookMarkID := sdvLeafXmj.Current.ValueByName('ID').AsInteger
  else
    iBookMarkID := -1;
  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) and CheckFilterLeafXmj(vNode) then
          AddLeafXmj(vNode, iNode);
      end;
    end;
  finally
    sddLeafXmj.EnableControls;
    sddLeafXmj.EndUpdate;
    if iBookMarkID <> -1 then
    begin
      if Assigned(sddLeafXmj.FindKey('idxID', iBookMarkID)) then
        sdvLeafXmj.LocateInControl(sddLeafXmj.FindKey('idxID', iBookMarkID))
      else if sddLeafXmj.RecordCount > 0 then
        sdvLeafXmj.LocateInControl(sddLeafXmj.Records[0]);
    end
    else if sddLeafXmj.RecordCount > 0 then
      sdvLeafXmj.LocateInControl(sddLeafXmj.Records[0]);
  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;

procedure TLeafXmjGlData.sdvLeafXmjGLSetText(var Text: String;
  ARecord: TsdDataRecord; AValue: TsdValue; AColumn: TsdViewColumn;
  var Allow: Boolean);
begin
  if SameText(AColumn.FieldName, 'UsedQuantity') then
  begin
    if (Text <> AValue.AsString) and (Text <> '') then
    begin
      with TProjectData(FProjectData).PhaseData.StageLeafXmjGlData do
        Text := FloatToStr(Decimal.Quantity.RoundTo(StrToFloatDef(Text, 0)));
    end;
  end;
end;

procedure TLeafXmjGlData.sdvLeafXmjGLGetText(var Text: String;
  ARecord: TsdDataRecord; AValue: TsdValue; AColumn: TsdViewColumn;
  DisplayText: Boolean);

  procedure GetDisplayText;
  begin
    if AValue.Field.DataType = ftFloat then
    begin
      if AValue.AsFloat = 0 then
        Text := '';
    end;
  end;

begin
  if DisplayText then
    GetDisplayText;
end;

function TLeafXmjGlData.CheckWithoutUsedQuantity(AIndex: Integer): Boolean;
var
  vRec: TsdDataRecord;
  vIdx: TsdIndex;
  iRec, iFirst, iLast: Integer;
  Rec: TLeafXmjGlRecord;
  StageRec: TStageLeafXmjGlRecord;
begin
  Result := False;
  if AIndex < sddLeafXmj.RecordCount then
  begin
    vRec := sddLeafXmj.Records[AIndex];
    vIdx := sddLeafXmjGL.FindIndex('idxXmj');
    iFirst := vIdx.FindKeyIndex(vRec.ValueByName('ID').AsInteger);
    iLast := vIdx.FindKeyLastIndex(vRec.ValueByName('ID').AsInteger);
    if iFirst >= 0 then
    begin
      for iRec := iFirst to iLast do
      begin
        Rec := TLeafXmjGlRecord(vIdx.Records[iRec]);
        StageRec := TStageLeafXmjGlRecord(Rec.StageRec);
        if Assigned(StageRec) and (StageRec.Quantity.AsFloat <> 0) and (StageRec.UsedQuantity.AsFloat = 0) then
        begin
          Result := True;
          Break;
        end;
      end;
    end;
  end;
end;

end.