bogdanpolak / delphi-dataproxy Goto Github PK

A above

Change option GenCommentsWithPublicDataSet to TDataSetAccess

type
  TDataSetAccess = (dsaNoAccess, dsaGenComment, dsaFullAccess);

  TDataProxyGenerator = class(TComponent)
    DataSetAccess: TDataSetAccess;

• Add to Comp.Proxy.CodeGenerator code:
• Add FFieldCount to TGenericDataProxy

procedure TBookProxy.ConnectFields;
var 
  ExpectedFieldCount: integer;
begin
  FISBN := FDataSet.FieldByName('ISBN') as TWideStringField;
  ...
  ExpectedFieldCount := 10;
  FFieldCount := FDataSet.Fields.Count;
  Assert (FFieldCount=ExpectedFieldCount);
end;

Add new folder: proxy with Data.Proxy.pas

Get file:
https://github.com/bogdanpolak/akademia/blob/master/projects/09-DataSetProxy/Data.DataProxy.pas

• Change ForEach method to:

procedure TDatasetProxy.ForEach(OnElem: TProc);
var
  Bookmark: TBookmark;
begin
  self.DisableControls;
  try
    Bookmark := FDataSet.GetBookmark;
    try
      self.First;
      while not FDataSet.Eof do
      begin
        OnElem();
        FDataSet.Next;
      end;
    finally
      if FDataSet.BookmarkValid(Bookmark) then
        FDataSet.GotoBookmark(Bookmark);
      FDataSet.FreeBookmark(Bookmark);
    end;
  finally
    FDataSet.EnableControls;
  end;
end;

• Add Eof method:

function TGenericDataSetProxy.Eof: boolean;
begin
  Result := FDataSet.Eof;
end;

Steps:

1. Select 2 different FireDAC connection definition:
   a) select definition, click [Connect] button, click [Disconnect] button
2. Restart application
3. Select yet another different (third) connection definition
4. Restart

Bug: Only two last definition will be visible in the menu

1. Rename Comp.GenerateDataSetCode.pas to Comp.Generator.DataSetCode.pas
2. Add code signature with version number and release date

See #16

Describe why to use TProxyDataset descendant component created by GeneratorApp?

New factory structure:

TDataProxyFactory = class
public
  class procedure RegisterDataSet(AProxyClass: TDataProxyClass; 
    const AConfigurationName: string; ADataSetCreateFun: TFun<TDataSet>); 
  class procedure SetDatasetConfiguration (AProxyClass: TDataProxyClass; 
    const AConfigurationName: string);
  class function CreateProxy (AProxyClass: TDataProxyClass; 
    AOwner: TComponent);
end;

Registration sample

TDataProxyFactory.RegisterDataSet(TBookProxy, 'FireDAC-dsBook', 
  function (): TDataSet;
  begin
    Result := TFDQuery.Create(AOwner);
    (Result as TFDQuery).Connection := FDConnection1;
    (Result as TFDQuery).SQL.Texr := 'SELECT ISBN, Title, Authors, ' +
      'Status, ReleseDate, Pages, Price, Currency, Imported, Description '+
      'FROM Books WHERE ReleaseDate > :ReleaseDate';
  end);
TDataProxyFactory.RegisterDataSet(TBookProxy, 'Mem-dsBook', CreateMockTableBook);

Configuration sample

TDataProxyFactory.SetDatasetConfiguration (TBookProxy, 'Mem-dsBook');

Usage sample

BookProxy := TDataProxyFactory.CreateProxy<TBookProxy>(AOwner)
BookProxy.Open ([EncodeDate(2018,01,01)],[ftDateTime])

1. Start refactoring of Unit Tests:
   • Rename project DUnitxProxyGeneratorComponent.dpr
   • Split tests into smaller units if it is possible
   • Clean 3xA sections in test cases
2. Refine and add refactoring issues for new sprint
   • For more complicated refactorings

Implement empty function: Gen_UnitHeader
in TDataProxyGenerator
add tests (implement with TDD)

1. Add test for WithDataSet

Remove

1. MemDataSet: TFDMemTable;
   • Use function Given_Dataset: TDataSet;
2. Copy methods which is comparing multiline strings
3. Remove: TProxyTemplates
   • rebuild all templates
   • use instead: inplace text
4. Rebuild wrapper: TTestProxyDataGenerator
   • methods convert to functions

(for unit testing) Code generator sholud generate somple code with creation of the fake memory DataSet (TFDMemTable) filled with a random data

1. Merge units: Data.DataProxy.pas with Data.DataProxy.Factory.pas
2. Rename: Data.DataProxy.pas to Data.Proxy.pas
3. Add: procedure AppendRecord(const Values: array of const); / InsertRecord
4. Add procedure PlugInto (ADataSource: TDataSource);
5. Add function ConstructDataSource: TDataSource;

1. Rename tab [Generated DAO Code] => [Generated Proxy]
2. Add UI control to change proxy options:
   • property DataSetAccess
   • property FieldNamingStyle
   • other properties added in version 1.0

Correct the descriptions in them main README to make them more readable and clean

Factory API

type
  TDataProxyFactory = class
    class function CreateProxy<T: TDataSetProxy> (Owner: TComponent; 
      ADataSet: TDataSet): T;
  end;

Factory usage

RDBMS SQL data set:

function CreateSQLDataSet_Book (AOwner: TComponent; AConnection: TFDConnection);
begin
  fdq := TFDQuery.Create(AOwner);
  with fdq do begin
    Connection := AConnection;
    SQL.Text := 'SELECT ISBN, Title, Authors, Status, ReleseDate,' +
      ' Pages, Price, Currency, Imported, Description FROM Books';
    Open;
  end;
  Result := fdq;
end;

procedure Form1Create (Sender: TObject);
begin
  ds := CreateSQLDataSet_Book(Self, FDConnection1);   
  BookProxy := TDataProxyFactory. CreateProxy<TBookProxy> (Self, ds);
end;

Memory (mock) data set:

procedure Form1Create (Sender: TObject);
begin
  ds := CreateMemDataSet_Book(Self);
  BookProxy := TDataProxyFactory. CreateProxy<TBookProxy> (Self, ds);
end;

Update:

• component TDSGenerator (previously TGenerateDataSetCode) to most recent version 1.3

Add edit control to enter proxy name:

Default text: {ObjectName}

On edit control change:

• Update generated proxy class name
• All places in generated code with {ObjectName} code should be updated

1. Generator shouldn't create mock datasets
   • Use project as supportive: https://github.com/bogdanpolak/dataset-generator
2. Use full functionality of TProxyGenerator to generate full unit
   • add option to generate title comment

Requires external support
More details: #16

In /doc/compare-dataset-vs-proxy.md finish the description Why using proxy?
Proxy pros and cons,
Continues #18

Redesign a class TDataProxyFactory stored in the Data.DataProxy.Factory.pas unit (folder /samples/base/)
Any sugestions?

Is now:

uses
  System.SysUtils,
  Database.Connector;

should be:

uses
  System.SysUtils,
  System.Classes,
  FireDAC.Comp.Client; // for them mock FDMemTable (or separate units)

Generate whole unit ready to save with:

• unit clause and unit name:
  unit proxy.{ObjectName};
• end.

This component interface was fully redesign, upgrade will require extensive code refactoring. About new component interface more info is here: GitHub - bogdanpolak - datasetToDelphiCode - issues 13

New dialog form which will allow to select database objects (tables and views) and build SELECT statement with full field list. Also will allow to add INNER JOIN tables with foreign key verification

Steps

1. Select connection definition
2. Click [Connect] button

Bug: mru menu in not updated (no definition)

Build new UI for:

Parameters on the left and more visible updates

TBookProxy

• Remove functions: ToString, CountMoreExpensiveBooks, LocateISBN
• Remove properties: Authors, Status, Currency, Imported, Description
• Add: Data.DataProxy prefix to TDatasetProxy

function CreateMockTableBook

• Update fields to TBookProxy

New

• Add sample with TDataProxyFactory: registration, configuration and usage

Adding support for FireDAC is in issue #26
Analyze how to exend this support into diffrent DAC packages: AnyDAC, ADO, IBX and other.
Consider using: Chain of Responsibility pattern:
https://refactoring.guru/design-patterns/chain-of-responsibility

In the generated Delphi code should be also code for the SQL and DataProxy. Something like:

const
  SQLSELECT_OneMonthOrders = 'SELECT * FROM Orders '+
  'WHERE {month ORDERDATE} = :MONTH AND {year  ORDERDATE} = :YEAR';
procedure RegisterSQLProxy;
begin
  AppDataProxyFactory.RegisterSQLProxy (TOrdersProxy, SQLSELECT_OneMonthOrders);
end;

And sample DataProxyFactory construction method, eg.:

var
  OrdersProxy: TOrdersProxy;
begin
  OrdersProxy :=  AppDataProxyFactory.ConstructAndOpenProxy (TOrdersProxy, [12, 2018]);
  ...

In tab: [Generated DAO Code]

1. WHEN:
   • Change text field: [Proxy Name]
2. THEN:
   • No changes are applied and text field content is reseted

Verify which version of Delphi IDE is required to compile the Generator App. Source code was written with Delphi 10.2, but should work with an older versions.

Community feedback is welcome!

Folders:

• doc - (no change)
• generator -> tools\generator-app
• proxy -> src
• samples - (no change)
• tests - (no change)

New (separate ER):

• tools\bumper-source

Update documentation according to this changes

README.md

Tasks:

1. Remove Generator App from main README
   • move to Generator App documentation to separate document
   • update diagrams
2. Merge Using TProxyDataSet in action with main README
3. Merge TDataSet vs TDataSetProxy with main README as introduction
4. Separate memory dataset generation as separate subject for unit testing
5. Describe TDataSetProxy as a tool for extracting logic form legacy projects
6. Separate two sections:
   • refactoring dataset into TDataSetProxy
   • inserting extracted code into unit test harness
7. Point DataSet Generator as a supportive project
8. Remove TDataProxyFactory use WithDataSet
9. Update docs according to current folder structure:
   • proxy -> src
   • generator -> tools\generator-app
10. Expnlain fake datasets generator as supportive project
    • point source repo: https://github.com/bogdanpolak/dataset-generator

Method TGenericDataSetProxy.Open should be allow to open queries and stored procedures with parameters. Add support for FireDAC in the Open method:

if (FDataSet is TFDRdbmsDataSet) then
  (FDataSet as TFDRdbmsDataSet).Open (AParamValues, AParamTypes);

In the generated proxy code is:

procedure T{ObjectName}Proxy.ConnectFields;
begin
  ORDERID := FDataSet.FieldByName('ORDERID') as TIntegerField;
  CUSTOMERID := FDataSet.FieldByName('CUSTOMERID') as TStringField;

but should be

procedure T{ObjectName}Proxy.ConnectFields;
begin
  FORDERID := FDataSet.FieldByName('ORDERID') as TIntegerField;
  FCUSTOMERID := FDataSet.FieldByName('CUSTOMERID') as TStringField;

Build SELECT statement with INNER JOIN tables. Fetch foreign key for main table. See more #2

WHEN:

1. [ Select Connection ]
2. Select any connection which is not working (not connecting)
   1, [ Connect ]
3. Close application
4. Memory leaks will be displayed