Infra Framework For Delphi
The InfraFramework4Delphi it is an API that provides a base infrastructure for the Delphi application development using a layered architecture.
It is important to stress that the InfraFramework4Delphi not forces any type of architecture for applications, which may consist of many layers as necessary. However, it is prudent not exaggerate! For those who do not know where to start, I suggest an architecture widely used by market standards in order to facilitate maintenance and to better modularize your project.
Usually, applications are composed of at least three layers, so it is common to separate the logic of presentation, business rules and persistence. The InfraFramework4Delphi provides mechanisms to make this clearer separation. For organizational reasons, it is recommended that no layer is circumvented. In practical terms, the presentation layer accesses the business layer, which, in turn, accesses the persistence.
Its premise is to facilitate the use layering without losing productivity, ie, enables the use of all the power of DBware components. In InfraFramework4Delphi the Persistence layer is represented by Data Modules with their corresponding data access components, the Business layer is represented by a derived class of TBusinessController and is responsible for all business rule, and the View layer is represented by Form and components of interaction with the user.
The InfraFramework4Delphi further provides libraries useful auxiliary for developing any Delphi application and requires Delphi 2010 or greater.
Persistence Adapters Drivers
The InfraFramework4Delphi is available for the following data access drivers:
- FireDAC
- ADO
External Dependencies
The InfraFramework4Delphi makes use of some external dependencies. Therefore these dependences are included in the project within the "dependencies" folder. If you use the library parser you should add to the Path SQLBuilder4Delphi.
- SQLBuilder4Delphi: https://github.com/ezequieljuliano/SQLBuilder4Delphi
Samples
Within the project there are a few examples of API usage. In addition there are also some unit tests that can aid in the use of InfraFramework4Delphi.
Using InfraFramework4Delphi
Using this API will is very simple, you simply add the Search Path of your IDE or your project the following directories:
- InfraFramework4Delphi\dependencies\SQLBuilder4Delphi\dependencies\gaSQLParser\src
- InfraFramework4Delphi\dependencies\SQLBuilder4Delphi\src
- InfraFramework4Delphi\src\layers
- InfraFramework4Delphi\src\utilities
InfraFramework4Delphi in 5 Minutes
Here is a step by step how to create a Delphi application into layers using the FireDAC components:
First you must create a Data Module responsible for the connection to your database. Example:
uses
InfraFwk4D.Persistence,
InfraFwk4D.Persistence.Adapter.FireDAC;
type
TDALConnection = class(TDataModule)
FDConnection: TFDConnection;
FDGUIxWaitCursor: TFDGUIxWaitCursor;
FDPhysSQLiteDriverLink: TFDPhysSQLiteDriverLink;
procedure DataModuleCreate(Sender: TObject);
procedure DataModuleDestroy(Sender: TObject);
private
fConnection: IDBConnection<TFDConnection>;
fSession: IDBSession;
public
function GetSession: IDBSession;
end;
After you create your Persistence Layer (DAO - Data Access Object) and your Datasets and Fields. Example:
uses
InfraFwk4D.Persistence.Template.FireDAC {You can use a ready-made template or build your own},
InfraFwk4D.DataSet.Iterator,
InfraFwk4D.Persistence;
TCountryDAO = class(TPersistenceTemplateFireDAC)
Country: TFDQuery;
CountryID: TIntegerField;
CountryNAME: TStringField;
private
{ Private declarations }
public
function FindByName(const name: string): IDataSetIterator;
function FindById(const id: Integer): IDataSetIterator;
function FindAll: IDataSetIterator;
procedure FilterById(const id: Integer);
procedure Desfilter;
procedure UpdateNameById(const name: string; const id: Integer);
end;
Now create your Business Rules Layer. For that inherit the business module informing the Persistence Layer. Example:
uses
InfraFwk4D.Business,
Country.DAO;
TCountryBC = class(TBusinessController<TCountryDAO>)
private
fCount: Integer;
protected
{ protected declarations }
public
procedure ProcessCounting;
property Count: Integer read fCount;
end;
Finally, create a new Form to be the View Layer. The View Layer will interact with the Business Rules Layer. Example:
uses
Country.DAO,
Country.BC;
type
TCountryView = class(TForm)
DBGrid1: TDBGrid;
DBNavigator1: TDBNavigator;
DsoCountry: TDataSource;
Panel1: TPanel;
Button2: TButton;
Button1: TButton;
Button3: TButton;
Label1: TLabel;
Button4: TButton;
Button5: TButton;
Button6: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure Button5Click(Sender: TObject);
procedure Button6Click(Sender: TObject);
private
fCountryBC: TCountryBC;
public
{ public declarations }
end;
Message Context
A well structured application, either on the Web or Desktop platform, should display informational message, warning, or error to the user after performing certain tasks. In summary, it must be programmed to exchange messages between different layers of an object oriented implementation. The implementation of the message context has been designed in a simple and flexible way, regardless of layer, leaving you free to implement their own solution or use the existing extensions.
Creating Its Implementation
The key to the message module is the IMessageAppender interface. To create a new mechanism for show messages, you only need to implement the interface in your application. Below is a sample implementation:
uses
InfraFwk4D.Message,
Vcl.Forms,
Winapi.Windows;
type
TMessageAppender = class(TInterfacedObject, IMessageAppender)
private
const APP_NAME = 'MESSAGE APP';
protected
procedure Append(message: IMessage); overload;
procedure Append(question: IQuestion); overload;
public
{ public declarations }
end;
implementation
{ TMessageAppender }
procedure TMessageAppender.Append(message: IMessage);
begin
case message.GetSeverity of
svInfo:
Application.MessageBox(PChar(message.GetText), PChar(APP_NAME), MB_ICONINFORMATION + MB_OK);
svWarn:
Application.MessageBox(PChar(message.GetText), PChar(APP_NAME), MB_ICONWARNING + MB_OK);
svError, svFatal:
Application.MessageBox(PChar(message.GetText), PChar(APP_NAME), MB_ICONERROR + MB_OK);
end;
end;
procedure TMessageAppender.Append(question: IQuestion);
var
focus: Integer;
begin
focus := MB_DEFBUTTON1;
if (question.GetFocus = reNo) then
focus := MB_DEFBUTTON2;
case Application.MessageBox(PChar(question.GetText), PChar(APP_NAME), MB_ICONQUESTION + MB_YESNO + focus) of
IDYES: question.SetResponse(reYes);
IDNO: question.SetResponse(reNo);
end;
end;
Now add in the message context of your appender:
uses
InfraFwk4D.Message,
InfraFwk4D.Message.Impl;
procedure TTestInfraFwkMessage.TestMessageContext;
var
msgCtx: IMessageContext;
begin
msgCtx := TMessageContext.Create;
msgCtx.RegisterAppender(TMessageAppender.Create);
msgCtx.Display('test info message %d', svInfo, [1]);
msgCtx.Display('test info message 2', svInfo);
msgCtx.Display('test info message 3');
CheckTrue(msgCtx.Ask('question %d?', reYes, [1]) = reYes);
CheckTrue(msgCtx.Ask('question 2?', reYes) = reYes);
CheckTrue(msgCtx.Ask('question 3?') = reYes);
end;
Validator Context
Validator Context allows to express and validate application constraints. The default metadata source are annotations. Enables you to incorporate validation into your application data through an easy-to-use and customize API.
Examples:
uses
InfraFwk4D.Validation.Default.Attributes;
TEntity = class
private
[AssertFalse]
fFalseValue: Boolean;
fTrueValue: Boolean;
[Max(20)]
fMaxValue: Integer;
fMinValue: Integer;
[Size(5, 10)]
fSizeValue: string;
[NotNull]
fNotNullValue: string;
[Null]
fNullValue: string;
[Past]
fPastValue: TDateTime;
[Present]
fPresentValue: TDateTime;
[Future]
fFutureValue: TDateTime;
[DecimalMax(20.5)]
fDecimalMaxValue: Double;
[DecimalMin(10.5)]
fDecimalMinValue: Double;
[NotNullWhen('fMaxValue', 20)]
fNotNullWhenValue: string;
[NotNullWhen('fFalseValue', False)]
fNotNullWhenBooleanValue: string;
[NotNullIn('fMaxValue', '10;20;30')]
fNotNullInValues: string;
[AssertIn('10;20;30')]
fAssertInValue: string;
public
constructor Create;
property FalseValue: Boolean read fFalseValue write fFalseValue;
[AssertTrue]
property TrueValue: Boolean read fTrueValue write fTrueValue;
property MaxValue: Integer read fMaxValue write fMaxValue;
[Min(5)]
property MinValue: Integer read fMinValue write fMinValue;
property SizeValue: string read fSizeValue write fSizeValue;
property NotNullValue: string read fNotNullValue write fNotNullValue;
property NullValue: string read fNullValue write fNullValue;
property PastValue: TDateTime read fPastValue write fPastValue;
property PresentValue: TDateTime read fPresentValue write fPresentValue;
property FutureValue: TDateTime read fFutureValue write fFutureValue;
property DecimalMaxValue: Double read fDecimalMaxValue write fDecimalMaxValue;
property DecimalMinValue: Double read fDecimalMinValue write fDecimalMinValue;
property NotNullWhenValue: string read fNotNullWhenValue write fNotNullWhenValue;
property NotNullWhenBooleanValue: string read fNotNullWhenBooleanValue write fNotNullWhenBooleanValue;
property NotNullInValues: string read fNotNullInValues write fNotNullInValues;
property AssertInValue: string read fAssertInValue write fAssertInValue;
end;
TModel = class(TDataModule)
Entity: TClientDataSet;
[AssertFalse]
EntityFalseValue: TBooleanField;
[AssertTrue]
EntityTrueValue: TBooleanField;
[Max(20)]
EntityMaxValue: TIntegerField;
[Min(5)]
EntityMinValue: TIntegerField;
[Size(5, 10)]
EntitySizeValue: TStringField;
[NotNull]
EntityNotNullValue: TStringField;
[Null]
EntityNullValue: TStringField;
[Past]
EntityPastValue: TDateField;
[Present]
EntityPresentValue: TDateField;
[Future]
EntityFutureValue: TDateField;
[DecimalMax(20.5)]
EntityDecimalMaxValue: TFloatField;
[DecimalMin(10.5)]
EntityDecimalMinValue: TFloatField;
[NotNullWhen('EntityMaxValue', '20')]
EntityNotNullWhenValue: TStringField;
[NotNullWhen('EntityFalseValue', False)]
EntityNotNullWhenBooleanValue: TStringField;
[NotNullIn('EntityMaxValue', '10;20;30;40')]
EntityNotNullInValues: TStringField;
[AssertIn('10;20;30')]
EntityAssertInValue: TStringField;
procedure DataModuleCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;