mORMot Open Source

Interface:
  ILongWorkCallback = interface(IInvokable)
    ['{C443AF11-E137-43D3-AB75-1CEC17FE30B2}']
    procedure WorkFinished(const worktype : Integer;
                                 timeTaken: integer;
                           const AResult:  RawByteString);

Server:
AStream: TRawByteStringStream

frxPDFExport.Stream := AStream;
frxPDFExport.ShowDialog := False;
frxReport.PrepareReport(True);
frxReport.Export(AfrxPDFExport);

AStream.seek(0,soBeginning);

fCallback.WorkFinished(fWorktype,GetTickCount64 - ftix,AStream.DataString);

Client:
v_Stream  : TMemoryStream;

v_Stream := TMemoryStream.Create;
WriteStringToStream(v_Stream,AResult);
v_Stream.Position := 0;
v_Stream.SaveToFile(v_filename);
v_Stream.Free;

TSQLCPU_COUNTRY = class(TSQLRecord)
  private
    fIDCOUNTRY : Integer;
    fNAME      : RawUTF8;
  published
    property IDCOUNTRY : Integer read fIDCOUNTRY write fIDCOUNTRY;
    property NAME      : RawUTF8 read fNAME      write fNAME;
  end;

TSQLCPU_STATE = class(TSQLRecord)
  private
    fIDCOUNTRY   : TSQLCPU_COUNTRY;
    //fIDCOUNTRY : Integer;
    fIDUF      : RawUTF8;
    fNAME      : RawUTF8;
    fCODUF     : Integer;
  published
    property IDCOUNTRY   : TSQLCPU_COUNTRY read fIDCOUNTRY write fIDCOUNTRY;
    property IDUF      : RawUTF8 read fIDUF      write fIDUF;
    property NAME      : RawUTF8 read fNAME      write fNAME;
    property CODUF     : Integer read fCODUF     write fCODUF;
  end;

v_cpucountry := TSQLCPU_STATE.CreateAndFillPrepareJoined(frmDM.fRestClient,'',[],[]);
dsCountry.DataSet := TSynSQLTableDataSet.Create(Self,v_cpucountry.FillTable);

Server side:
  TDBServerList = class
    private
      FDBServers : TRawUTF8List;
      FPropsList : TRawUTF8List;
    public
      constructor Create;
      destructor  Destroy;override;

      procedure AddServer(const ASessionID: Cardinal;
                          const AServerDB: TSQLRestServerDB);
      procedure RemoveServer(const ASessionID: Cardinal);
      function GetServer(const ASessionID: Cardinal): TSQLRestServerDB;

      procedure AddProps(const ASessionID: Cardinal;
                         const AProps: TSQLDBConnectionProperties);
      procedure RemoveProps(const ASessionID: Cardinal);
      function GetProps(const ASessionID: Cardinal): TSQLDBConnectionProperties;
  end;

{ TDBServerList }

procedure TDBServerList.AddProps(const ASessionID: Cardinal;
                                 const AProps: TSQLDBConnectionProperties);
begin
   FPropsList.AddObject(IntToStr(ASessionId), AProps);
end;

procedure TDBServerList.AddServer(const ASessionID: Cardinal;
                                  const AServerDB: TSQLRestServerDB);
begin
   FDBServers.AddObject(IntToStr(ASessionId), AServerDB);
end;

constructor TDBServerList.Create;
begin
   FDBServers := TRawUTF8List.Create(True);
   FPropsList := TRawUTF8List.Create(True);
end;

destructor TDBServerList.Destroy;
var
  v_count: Integer;
begin
   {for v_count := 0 to FDBServers.Count-1 do
      TSQLRestServerDB(FDBServers.Objects[v_count]).Free;}
   FDBServers.Free;

   {for v_count := 0 to FPropsList.Count-1 do
      TSQLDBConnectionProperties(FPropsList.Objects[v_count]).Free;}
   FPropsList.Free;

  inherited;
end;

function TDBServerList.GetProps(const ASessionID: Cardinal): TSQLDBConnectionProperties;
begin
   Result := TSQLDBConnectionProperties(FPropsList.Objects[FPropsList.IndexOf(IntToStr(ASessionId))]);
end;

function TDBServerList.GetServer(const ASessionID: Cardinal): TSQLRestServerDB;
begin
   Result := TSQLRestServerDB(FDBServers.Objects[FDBServers.IndexOf(IntToStr(ASessionId))]);
end;

procedure TDBServerList.RemoveProps(const ASessionID: Cardinal);
var
   v_pt: PtrInt;
begin
   v_pt := FPropsList.IndexOf(IntToStr(ASessionId));
   if v_pt >= 0 then
      FPropsList.Delete(v_pt);
end;

procedure TDBServerList.RemoveServer(const ASessionID: Cardinal);
var
   v_pt: PtrInt;
begin
   v_pt := FDBServers.IndexOf(IntToStr(ASessionId));
   if v_pt >= 0 then
      FDBServers.Delete(v_pt);
end;


function TServiceRemoteSQL.fn_connectdb(const AServer,
                                              AUserName,
                                              APassword,
                                              AServerName,
                                              ADataBase: RawUTF8;
                                        const AEngine: TRemoteSQLEngine;
                                        const ASessionID: Cardinal): RawUTF8;
const // rseOleDB, rseODBC, rseOracle, rseSQlite3, rseJet, rseMSSQL, rseFirebird
  TYPES: array[TRemoteSQLEngine] of TSQLDBConnectionPropertiesClass = (
     TOleDBConnectionProperties,
     TODBCConnectionProperties,
     TSQLDBOracleConnectionProperties,
     TSQLDBSQLite3ConnectionProperties,
     {$ifdef WIN64}nil{$else}TOleDBJetConnectionProperties{$endif},
     TOleDBMSSQL2008ConnectionProperties,
     TSQLDBFireDACConnectionProperties);
var
   fProps    : TSQLDBConnectionProperties;
   aServerDB : TSQLRestServerDB;
   fModel    : TSQLModel;
begin
   Result := '';
   if TYPES[aEngine] = nil then
   begin
      Result := StringToUTF8(Format(frmServAppRM.OLANG.fn_lerini('Mens',
                                                                 'cpuMMensEngineNotSup',
                                                                 'cpuMMensEngineNotSup') +
                                    ' ',
                                    [GetEnumName(TypeInfo(TRemoteSQLEngine),
                                                 ord(aEngine))^]));
     FreeAndNil(fProps);
   end
   else
   begin
      // Conectando Firebird
      fProps := TYPES[aEngine].Create(aServerName,
                                      aServer +
                                      ':' +
                                      ADataBase,
                                      AUserName,
                                      aPassWord);
      try
         fProps.MainConnection.Connect;

         // clonando model
         fModel := TSQLModel(frmServAppRM.aModel);

         // registrar tabelas do banco
         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_COMPANY,
                                      fProps,
                                      'CPU_COMPANY');
         fModel.Props[TSQLCPU_COMPANY].ExternalDB.MapField('ID','IDCOMPANY');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_USER,
                                      fProps,
                                      'CPU_USER');
         fModel.Props[TSQLCPU_USER].ExternalDB.MapField('ID','IDUSER');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_PROCESS,
                                      fProps,
                                      'CPU_PROCESS');
         fModel.Props[TSQLCPU_PROCESS].ExternalDB.MapField('ID','IDPROCESS');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_SYSTEM,
                                      fProps,
                                      'CPU_SYSTEM');
         fModel.Props[TSQLCPU_SYSTEM].ExternalDB.MapField('ID','IDSYSTEM');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_SYSTEMS,
                                      fProps,
                                      'CPU_SYSTEMS');
         fModel.Props[TSQLCPU_SYSTEMS].ExternalDB.MapField('ID','IDSYSTEMS');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_PROGRAM,
                                      fProps,
                                      'CPU_PROGRAM');
         fModel.Props[TSQLCPU_PROGRAM].ExternalDB.MapField('ID','IDSYSTEM');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FORM,
                                      fProps,
                                      'CPU_FORM');
         fModel.Props[TSQLCPU_FORM].ExternalDB.MapField('ID','IDFORM');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FORMFILTER,
                                      fProps,
                                      'CPU_FORMFILTER');
         fModel.Props[TSQLCPU_FORMFILTER].ExternalDB.MapField('ID','IDFORM').
                                                                  MapField('IDFILTER','IDFILTER');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FORMTABSHEET,
                                      fProps,
                                      'CPU_FORMTABSHEET');
         fModel.Props[TSQLCPU_FORMTABSHEET].ExternalDB.MapField('ID','IDFORM').
                                                                    MapField('IDTABSHEET','IDTABSHEET');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FTSSOURCE,
                                      fProps,
                                      'CPU_FTSSOURCE');
         fModel.Props[TSQLCPU_FTSSOURCE].ExternalDB.MapField('ID','IDFORM').
                                                                 MapField('IDTABSHEET','IDTABSHEET');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FORMSECCION,
                                      fProps,
                                      'CPU_FORMSECCION');
         fModel.Props[TSQLCPU_FORMSECCION].ExternalDB.MapField('ID','IDFORM').
                                                                   MapField('IDTABSHEET','IDTABSHEET').
                                                                   MapField('IDSECCION','IDSECCION');

         VirtualTableExternalRegister(fModel,
                                      TSQLCPU_FORMSECFIELD,
                                      fProps,
                                      'CPU_FORMSECFIELD');
         fModel.Props[TSQLCPU_FORMSECFIELD].ExternalDB.MapField('ID','IDFORM').
                                                                    MapField('IDTABSHEET','IDTABSHEET').
                                                                    MapField('IDSECCION','IDSECCION').
                                                                    MapField('IDFIELD','IDFIELD');

         aServerDB := TSQLRestServerDB.Create(fModel, ':memory:',false); // authentication=false
         aServerDB.CreateMissingTables;

         // iniciar o HTTP server
         frmServAppRM.aHTTPServer := TSQLHttpServer.Create(frmDMServer.fSettings.Port,
                                                           [aServerDB],
                                                           '+',
                                                           useHttpApiRegisteringURI);
        frmServAppRM. aHTTPServer.AccessControlAllowOrigin := '*'; // for AJAX requests to work

         // adicionando a lista
         frmDMServer.fDBServerList.AddServer(ASessionID,aServerDB);
         frmDMServer.fDBServerList.AddProps(ASessionID,fProps);
         //aServerDB.Free;
         //fModel.Free;
         //fProps.Free;
      except
         on E: Exception do
         begin
            FreeAndNil(fProps);
            Result := StringToUTF8(Format(frmServAppRM.OLANG.fn_lerini('Mens',
                                                                       'cpuMMensConerr',
                                                                       'cpuMMensConerr') +
                                   E.Message,
                                   [#13]));
         end;
      end;
   end;
end;