unit Quick.Core.Entity.Engine.RestServer;

{$IFDEF DEBUG_ENTITY}

Quick.Debug.Utils,

{$ENDIF}

Classes,

System.SysUtils,

System.Net.HttpClient,

System.Generics.Collections,

Quick.Commons,

Quick.RTTI.Utils,

Quick.Json.Serializer,

Quick.Core.Entity.DAO,

Quick.Core.Entity.Database,

Quick.Core.Entity.Query,

Quick.Core.Entity.Request;

TRestServerConnection = class

private

fHttpClient : THTTPClient;

fConnected : Boolean;

fHost : string;

fUser : string;

fPassword : string;

fSessionId : string;

procedure SetConnected(const Value: Boolean);

public

constructor Create;

destructor Destroy; override;

property Host : string read fHost write fHost;

property User : string read fUser write fUser;

property Password : string read fPassword write fPassword;

property Connected : Boolean read fConnected write SetConnected;

function GetTableNames : TArray<string>;

function GetFieldNames(const aTableName : string) : TArray<string>;

end;

TRestServerQuery<T : class, constructor> = class

private

fHttpClient : THTTPClient;

fConnection : TRestServerConnection;

fModel : TEntityModel;

fResults : TList<T>;

fSerializer : TJsonSerializer;

function RequestActionToStr(aRequestAction : TEntityRequestAction) : string;

public

constructor Create;

destructor Destroy; override;

property Connection : TRestServerConnection read fConnection write fConnection;

property Model : TEntityModel read fModel write fModel;

property Results : TList<T> read fResults write fResults;

function ConnectRequest(aRequest : TEntityConnectRequest; out vResult : string) : Boolean;

function SendRequest(aRequest: TEntityRequest): Boolean; overload;

function SendRequest(aAction : TEntityRequestAction; aValue : TEntity) : Boolean; overload;

function SendRequest(aRequest: TEntityRequest; out vResult : string): Boolean; overload;

end;

TRestServerEntityDataBase = class(TEntityDatabase)

private

fRestServerConnection : TRestServerConnection;

fInternalQuery : TRestServerQuery<TEntity>;

fDBProvider : TDBProvider;

function DoConnect(const aUser, aPassword : string): Boolean;

protected

function CreateConnectionString: string; override;

procedure DoExecuteSQLQuery(const aQueryText : string); override;

procedure DoOpenSQLQuery(const aQueryText: string); override;

function ExistsTable(aModel : TEntityModel) : Boolean; override;

function ExistsColumn(aModel: TEntityModel; const aFieldName: string): Boolean; override;

public

constructor Create; override;

constructor CreateFromConnection(aConnection: TRestServerConnection; aOwnsConnection : Boolean);

destructor Destroy; override;

function CreateQuery(aModel : TEntityModel) : IEntityQuery<TEntity>; override;

function Connect : Boolean; override;

procedure Disconnect; override;

function GetTableNames : TArray<string>; override;

function GetFieldNames(const aTableName : string) : TArray<string>; override;

function GetDriverID(aDBProvider : TDBProvider) : string;

function IsConnected : Boolean; override;

function From<T : class, constructor> : IEntityLinqQuery<T>;

function Clone : TEntityDatabase; override;

end;

TRestServerEntityQuery<T : class, constructor> = class(TEntityQuery<T>)

private

fConnection : TDBConnectionSettings;

fQuery : TRestServerQuery<T>;

fCurrentIndex : Integer;

protected

function GetCurrent : T; override;

function MoveNext : Boolean; override;

function GetFieldValue(const aName : string) : Variant; override;

function OpenQuery(const aQuery : string) : Integer; override;

function ExecuteQuery(const aQuery : string) : Boolean; override;

function FillRecordFromDB(aEntity : T) : T; override;

public

constructor Create(aEntityDataBase : TEntityDatabase; aModel : TEntityModel; aQueryGenerator : IEntityQueryGenerator); override;

destructor Destroy; override;

function CountResults : Integer; override;

function Eof : Boolean; override;

function AddOrUpdate(aEntity : TEntity) : Boolean; override;

function Add(aEntity : TEntity) : Boolean; override;

function Update(aEntity : TEntity) : Boolean; overload; override;

function Delete(aEntity : TEntity) : Boolean; overload; override;

function Delete(const aWhere : string) : Boolean; overload; override;

//LINQ queries

function SelectFirst : T; override;

function SelectLast : T; override;

function Select : IEntityResult<T>; overload; override;

function Select(const aFieldNames : string) : IEntityResult<T>; overload; override;

function SelectTop(aNumber : Integer) : IEntityResult<T>; override;

function Sum(const aFieldName : string) : Int64; override;

function Count : Int64; override;

function Update(const aFieldNames : string; const aFieldValues : array of const) : Boolean; overload; override;

function Delete : Boolean; overload; override;

end;

System.Net.URLClient,

System.Rtti,

System.NetConsts;

constructor TRestServerEntityDataBase.Create;

inherited;

fRestServerConnection := TRestServerConnection.Create;

fInternalQuery := TRestServerQuery<TEntity>.Create;

end;

constructor TRestServerEntityDataBase.CreateFromConnection(aConnection: TRestServerConnection; aOwnsConnection : Boolean);

Create;

if OwnsConnection then fRestServerConnection.Free;

OwnsConnection := aOwnsConnection;

fRestServerConnection := aConnection;

end;

destructor TRestServerEntityDataBase.Destroy;

if Assigned(fInternalQuery) then fInternalQuery.Free;

if fRestServerConnection.Connected then fRestServerConnection.Connected := False;

if OwnsConnection then fRestServerConnection.Free;

inherited;

end;

function TRestServerEntityDataBase.Clone: TEntityDatabase;

Result := TRestServerEntityDataBase.CreateFromConnection(fRestServerConnection,False);

Result.Connection.Free;

Result.Connection := Connection.Clone;

end;

function TRestServerEntityDataBase.Connect: Boolean;

//creates connection string based on parameters of connection property

{$IFDEF DEBUG_ENTITY}

TDebugger.TimeIt(Self,'Connect','');

{$ENDIF}

CreateConnectionString;

fRestServerConnection.Host := Connection.Server;

fRestServerConnection.User := Connection.UserName;

fRestServerConnection.Password := Connection.Password;

fInternalQuery.Connection := fRestServerConnection;

try

fRestServerConnection.Connected := DoConnect(Connection.UserName,Connection.Password);

except

on E : Exception do raise EEntityConnectionError.CreateFmt('Entity connection error: %s',[e.Message]);

end;

inherited;

Result := IsConnected;

//CreateTables;

//CreateIndexes;

end;

function TRestServerEntityDataBase.CreateConnectionString: string;

cs : string;

if Connection.IsCustomConnectionString then

begin

cs := Connection.GetCustomConnectionString;

Connection.Server := GetSubString(cs,'Server=',';');

Connection.UserName := GetSubString(cs,'UserName=',';');

Connection.Password := GetSubString(cs,'Password=',';');

end;

end;

function TRestServerEntityDataBase.CreateQuery(aModel: TEntityModel): IEntityQuery<TEntity>;

Result := TRestServerEntityQuery<TEntity>.Create(Self,aModel,QueryGenerator);

end;

procedure TRestServerEntityDataBase.Disconnect;

inherited;

fRestServerConnection.Connected := False;

end;

function TRestServerEntityDataBase.DoConnect(const aUser, aPassword : string): Boolean;

request : TEntityConnectRequest;

response : string;

request := TEntityConnectRequest.Create;

try

request.User := aUser;

request.Password := aPassword;

Result := fInternalQuery.ConnectRequest(request,response);

if Result then

begin

fDBProvider := TDBProvider(response.ToInteger);

Connection.Provider := fDBProvider;

end;

finally

request.Free;

end;

end;

procedure TRestServerEntityDataBase.DoExecuteSQLQuery(const aQueryText: string);

//Not needed: Theses operations were made on server part

//fInternalQuery.SQL.Text := aQueryText;

//fInternalQuery.ExecSQL;

end;

procedure TRestServerEntityDataBase.DoOpenSQLQuery(const aQueryText: string);

//Not needed: Theses operations were made on server part

//fInternalQuery.SQL.Text := aQueryText;

//fInternalQuery.Open;

end;

function TRestServerEntityDataBase.ExistsColumn(aModel: TEntityModel; const aFieldName: string): Boolean;

//Not needed: Theses operations were made on server part

Result := True;

end;

function TRestServerEntityDataBase.ExistsTable(aModel: TEntityModel): Boolean;

//Not needed: Theses operations were made on server part

Result := True;

end;

function TRestServerEntityDataBase.From<T>: IEntityLinqQuery<T>;

Entityclass : TEntityClass;

Entityclass := TEntityClass(Pointer(T));

Result := TRestServerEntityQuery<T>.Create(Self,Models.Get(Entityclass),QueryGenerator);

end;

function TRestServerEntityDataBase.GetDriverID(aDBProvider: TDBProvider): string;

case aDBProvider of

TDBProvider.dbMSAccess2007 : Result := 'MSAcc';

TDBProvider.dbMSSQL : Result := 'MSSQL';

TDBProvider.dbMySQL : Result := 'MySQL';

TDBProvider.dbSQLite : Result := 'SQLite';

else raise EEntityProviderError.Create('Unknow DBProvider or not supported by this engine');

end;

end;

function TRestServerEntityDataBase.GetFieldNames(const aTableName: string): TArray<string>;

Result := fInternalQuery.Connection.GetFieldNames(aTableName);

end;

function TRestServerEntityDataBase.GetTableNames: TArray<string>;

Result := fInternalQuery.Connection.GetTableNames;

end;

function TRestServerEntityDataBase.IsConnected: Boolean;

Result := fRestServerConnection.Connected;

end;

constructor TRestServerEntityQuery<T>.Create(aEntityDataBase : TEntityDatabase; aModel : TEntityModel; aQueryGenerator : IEntityQueryGenerator);

inherited;

fQuery := TRestServerQuery<T>.Create;

fQuery.Model := aModel;

fQuery.Connection := TRestServerEntityDataBase(aEntityDataBase).fRestServerConnection;

fConnection := aEntityDataBase.Connection;

end;

destructor TRestServerEntityQuery<T>.Destroy;

if Assigned(fQuery) then fQuery.Free;

inherited;

end;

function TRestServerEntityQuery<T>.OpenQuery(const aQuery : string) : Integer;

fFirstIteration := True;

raise ENotImplemented.Create('OpenQuery');

end;

function TRestServerEntityQuery<T>.ExecuteQuery(const aQuery : string) : Boolean;

raise ENotImplemented.Create('ExecuteQuery');

end;

function TRestServerEntityQuery<T>.FillRecordFromDB(aEntity: T) : T;

field : TDBField;

aEntity.Free;

Result := fQuery.Results[fCurrentIndex];

end;

function TRestServerEntityQuery<T>.GetFieldValue(const aName: string): Variant;

//raise ENotImplemented.Create('GetFieldValue');

Result := TRtti.GetPropertyValue(GetCurrent,aName).AsVariant;

//Result := fQuery.FieldByName(aName).AsVariant;

//Result := TRTTI.GetPropertyValue(fQuery.Results[0],aName).AsVariant;

end;

function TRestServerEntityQuery<T>.GetCurrent: T;

if Self.Eof then Exit(nil);

Result := fQuery.Results[fCurrentIndex];

fQuery.Results[fCurrentIndex] := nil;

end;

function TRestServerEntityQuery<T>.MoveNext: Boolean;

if not fFirstIteration then Inc(fCurrentIndex);

fFirstIteration := False;

Result := not Self.Eof;

end;

function TRestServerEntityQuery<T>.Add(aEntity: TEntity): Boolean;

Result := fQuery.SendRequest(TEntityRequestAction.raAdd,aEntity);

end;

function TRestServerEntityQuery<T>.AddOrUpdate(aEntity: TEntity): Boolean;

Result := fQuery.SendRequest(TEntityRequestAction.raAddOrUpdate,aEntity);

end;

function TRestServerEntityQuery<T>.Count: Int64;

request : TEntityCountRequest;

response : string;

request := TEntityCountRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raCount;

request.WhereClause := fWhereClause;

if fQuery.SendRequest(request,response) then Result := response.ToInt64;

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.CountResults: Integer;

Result := fQuery.Results.Count;

end;

function TRestServerEntityQuery<T>.Delete(aEntity: TEntity): Boolean;

raise ENotImplemented.Create('not implemented yet!');

end;

function TRestServerEntityQuery<T>.Delete: Boolean;

request : TEntityDeleteRequest;

request := TEntityDeleteRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raDelete;

request.WhereClause := fWhereClause;

Result := fQuery.SendRequest(request);

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.Delete(const aWhere: string): Boolean;

request : TEntityDeleteRequest;

request := TEntityDeleteRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raDelete;

request.WhereClause := aWhere;

Result := fQuery.SendRequest(request);

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.Eof: Boolean;

if fQuery.Results = nil then Exit(True);

Result := (fQuery.Results.Count = 0) or ((fCurrentIndex + 1) > fQuery.Results.Count);

end;

function TRestServerEntityQuery<T>.Select(const aFieldNames: string): IEntityResult<T>;

request : TEntitySelectRequest;

request := TEntitySelectRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raSelect;

request.Fields := aFieldNames;

request.Limit := 0;

request.WhereClause := fWhereClause;

request.Order := fOrderClause;

request.OrderAsc := fOrderAsc;

if fQuery.SendRequest(request) then Result := TEntityResult<T>.Create(Self);

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.Select: IEntityResult<T>;

request : TEntitySelectRequest;

try

request := TEntitySelectRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raSelect;

request.Fields := '';

request.Limit := 0;

request.WhereClause := fWhereClause;

request.Order := fOrderClause;

request.OrderAsc := fOrderAsc;

if fQuery.SendRequest(request) then Result := TEntityResult<T>.Create(Self);

finally

request.Free;

end;

except

on E : Exception do raise EEntitySelectError.Create(e.message);

end;

end;

function TRestServerEntityQuery<T>.SelectFirst: T;

request : TEntitySelectRequest;

Result := nil;

request := TEntitySelectRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raSelect;

request.Fields := '*';

request.Limit := 1;

request.WhereClause := fWhereClause;

request.Order := fOrderClause;

request.OrderAsc := fOrderAsc;

if fQuery.SendRequest(request) then

begin

Self.Movenext;

Result := Self.GetCurrent;

end;

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.SelectLast: T;

request : TEntitySelectRequest;

Result := nil;

request := TEntitySelectRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raSelect;

request.Fields := '*';

request.Limit := -1;

request.WhereClause := fWhereClause;

request.Order := fOrderClause;

request.OrderAsc := not fOrderAsc;

if fQuery.SendRequest(request) then

begin

Self.Movenext;

Result := Self.GetCurrent;

end;

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.SelectTop(aNumber: Integer): IEntityResult<T>;

request : TEntitySelectRequest;

request := TEntitySelectRequest.Create;

try

request.Table := fModel.TableName;

request.Action := TEntityRequestAction.raSelect;

request.Fields := '*';

request.Limit := aNumber;

request.WhereClause := fWhereClause;

request.Order := fOrderClause;

request.OrderAsc := fOrderAsc;

if fQuery.SendRequest(request) then Result := TEntityResult<T>.Create(Self);

finally

request.Free;

end;

end;

function TRestServerEntityQuery<T>.Sum(const aFieldName: string): Int64;

raise ENotImplemented.Create('not implemented yet!');

end;

function TRestServerEntityQuery<T>.Update(aEntity: TEntity): Boolean;

Result := fQuery.SendRequest(TEntityRequestAction.raUpdate,aEntity);

end;

function TRestServerEntityQuery<T>.Update(const aFieldNames: string; const aFieldValues: array of const): Boolean;

raise ENotImplemented.Create('not implemented yet!');

end;

constructor TRestServerConnection.Create;

fConnected := False;

fHttpClient := THTTPClient.Create;

end;

destructor TRestServerConnection.Destroy;

fHttpClient.Free;

inherited;

end;

function TRestServerConnection.GetFieldNames(const aTableName: string): TArray<string>;

end;

function TRestServerConnection.GetTableNames: TArray<string>;

end;

procedure TRestServerConnection.SetConnected(const Value: Boolean);

if Value then

begin

//do connection to RestServer

fConnected := True;

end

else

begin

//do disconnection from RestServer

fConnected := False;

end;

end;

constructor TRestServerQuery<T>.Create;

fHttpClient := THTTPClient.Create;

fHttpClient.UserAgent := 'Quick.Core.Entity.RestClient';

fHttpClient.ContentType := 'application/json';

fSerializer := TJsonSerializer.Create(TSerializeLevel.slPublishedProperty,True);

fResults := TList<T>.Create;

end;

destructor TRestServerQuery<T>.Destroy;

fHttpClient.Free;

fSerializer.Free;

fResults.Free;

inherited;

end;

function TRestServerQuery<T>.RequestActionToStr(aRequestAction: TEntityRequestAction): string;

Result := EntityRequestActionStr[aRequestAction];

end;

function TRestServerQuery<T>.SendRequest(aAction: TEntityRequestAction; aValue: TEntity): Boolean;

response : IHTTPResponse;

content : TStringStream;

content := TStringStream.Create(fSerializer.ObjectToJson(aValue));

try

{$IFDEF DEBUG_ENTITY}

var crono := TDebugger.TimeIt(Self,'SendRequest',RequestActionToStr(aAction) + ' Entity');

{$ENDIF}

if aAction = TEntityRequestAction.raAdd then response := fHttpClient.Post(Format('%s/api/%s',[Connection.Host,fModel.TableName]),content)

else if aAction = TEntityRequestAction.raAddOrUpdate then

begin

response := fHttpClient.Put(Format('%s/api/%s/AOU/%s',

[Connection.Host,fModel.TableName,aValue.FieldValueByName(fModel.PrimaryKey.Name)]),content);

end

else if aAction = TEntityRequestAction.raUpdate then

begin

response := fHttpClient.Put(Format('%s/api/%s/%s',

[Connection.Host,fModel.TableName,aValue.FieldValueByName(fModel.PrimaryKey.Name)]),content);

end

else raise EEntityRestRequestError.Create('Entity Method not allowed here');

{$IFDEF DEBUG_ENTITY}

crono.Stop;

{$ENDIF}

finally

content.Free;

end;

Result := response.StatusCode in [200,201];

if response.StatusCode in [200,201] then Result := True

else if response.StatusCode <> 404 then raise EEntityRestRequestError.Create(response.StatusText);

end;

function TRestServerQuery<T>.SendRequest(aRequest: TEntityRequest): Boolean;

response : IHTTPResponse;

content : TStringStream;

rescontent : TStringStream;

Result := False;

content := TStringStream.Create(fSerializer.ObjectToJson(aRequest));

try

rescontent := TStringStream.Create;

try

{$IFDEF DEBUG_ENTITY}

var crono := TDebugger.TimeIt(Self,'SendRequest', RequestActionToStr(aRequest.Action) + ' query');

{$ENDIF}

response := fHttpClient.Post(Format('%s/api/query/%s',[Connection.Host,RequestActionToStr(aRequest.Action)]),content,rescontent);

{$IFDEF DEBUG_ENTITY}

crono.Stop;

{$ENDIF}

if response.StatusCode in [200,201] then

begin

if aRequest.Action = TEntityRequestAction.raSelect then fSerializer.JsonToObject(fResults,rescontent.DataString);

Result := True;

end

else if response.StatusCode <> 404 then

begin

raise EEntityRestRequestError.Create(response.StatusText);

end;

finally

rescontent.Free;

end;

finally

content.Free;

end;

end;

function TRestServerQuery<T>.SendRequest(aRequest: TEntityRequest; out vResult : string): Boolean;

response : IHTTPResponse;

content : TStringStream;

rescontent : TStringStream;

Result := False;

content := TStringStream.Create(fSerializer.ObjectToJson(aRequest));

try

rescontent := TStringStream.Create;

try

{$IFDEF DEBUG_ENTITY}

var crono := TDebugger.TimeIt(Self,'SendRequest', RequestActionToStr(aRequest.Action) + ' query');

{$ENDIF}

response := fHttpClient.Post(Format('%s/api/query/%s',[Connection.Host,RequestActionToStr(aRequest.Action)]),content,rescontent);

{$IFDEF DEBUG_ENTITY}

crono.Stop;

{$ENDIF}

if response.StatusCode in [200,201] then

begin

vResult := response.ContentAsString;

Result := True;

end

else if response.StatusCode <> 404 then

begin

raise EEntityRestRequestError.Create(response.StatusText);

end;

finally

rescontent.Free;

end;

finally

content.Free;

end;

end;

function TRestServerQuery<T>.ConnectRequest(aRequest: TEntityConnectRequest; out vResult : string): Boolean;

response : IHTTPResponse;

content : TStringStream;

rescontent : TStringStream;

Result := False;

content := TStringStream.Create(fSerializer.ObjectToJson(aRequest));

try

rescontent := TStringStream.Create;

try

{$IFDEF DEBUG_ENTITY}

var crono := TDebugger.TimeIt(Self,'ConnectRequest', Format('Connecting to %s',[Connection.Host]));

{$ENDIF}

response := fHttpClient.Post(Format('%s/api/connect',[Connection.Host]),content,rescontent);

{$IFDEF DEBUG_ENTITY}

crono.Stop;

{$ENDIF}

if response.StatusCode in [200,201] then

begin

vResult := response.ContentAsString;

Result := True;

end

else if response.StatusCode <> 404 then

begin

raise EEntityRestRequestError.Create(response.StatusText);

end;

finally

rescontent.Free;

end;

finally

content.Free;

end;

end;

end.