Tecsitel_FactuGES2/Source/ApplicationBase/Usuarios/Data/uUCROConn.pas

{-----------------------------------------------------------------------------
 Unit Name: UCMidasConn
 Author   : Luiz Benevenuto
 Date     : 31/07/2005
 Purpose  : Midas Suporte ( DataSnap )
 E-mail   : luiz@siffra.com
 URL      : www.siffra.com
 UC       : www.usercontrol.com.br
 Forum    : http://www.usercontrol.com.br/modules.php?name=Forums

 registered in UCMidasConnReg.pas
-----------------------------------------------------------------------------}

unit uUCROConn;

interface

//{$I 'UserControl.inc'}

uses
  Classes,
  DB,
  DBClient,
  SysUtils,
  uRORemoteService, uDADataStreamer, uROBinMessage, uROIndyHTTPChannel,
  uDABin2DataStreamer, uDARemoteDataAdapter, UCDataConnector, uROClient;

type
  TUCROConn = class(TUCDataConnector)
  private
    FMessage: TROBinMessage;
    FChannel: TROIndyHTTPChannel;
    FRemoteService: TRORemoteService;
    FDataAdapter : TDARemoteDataAdapter;
    FDataStreamer : TDABin2DataStreamer;
    procedure SetServiceName(const Value: String);
    function GetServiceName: String;
    procedure SetChannel(const Value: TROIndyHTTPChannel);
    procedure SetMessage(const Value: TROBinMessage);
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    procedure RefreshROConnection;
  public
    function GetDBObjectName: String; override;
    function GetTransObjectName: String; override;
    function UCFindDataConnection: Boolean; override;
    function UCFindTable(const Tablename: String): Boolean; override;
    function UCGetSQLDataset(FSQL: String): TDataset; override;
    procedure UCExecSQL(FSQL: String); override;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property ROServiceName : String read GetServiceName write SetServiceName;
    property ROMessage : TROBinMessage read FMessage write SetMessage;
    property ROChannel : TROIndyHTTPChannel read FChannel write SetChannel;
  end;

implementation

uses
  Forms, Dialogs, FactuGES_Intf, uROTypes, uDAClasses, uDADataTable,
  uDACDSDataTable, uROEncryption;

{ TUCROConn }

constructor TUCROConn.Create(AOwner: TComponent);
begin
  inherited;
  FRemoteService := TRORemoteService.Create(nil);
  FDataStreamer := TDABin2DataStreamer.Create(nil);
  FDataAdapter := TDARemoteDataAdapter.Create(nil);
  FDataAdapter.DataStreamer := FDataStreamer;
  FDataAdapter.SetupDefaultRequest;
end;

destructor TUCROConn.Destroy;
begin
  FreeAndNil(FRemoteService);
  FreeAndNil(FDataAdapter);
  FreeAndNil(FDataStreamer);
  inherited;
end;

function TUCROConn.GetDBObjectName: String;
begin
  if Assigned(FRemoteService) then
  begin
    if Owner = FRemoteService.Owner then
      Result := FRemoteService.Name
    else
      Result := FRemoteService.Owner.Name + '.' + FRemoteService.Name;
  end
  else
    Result := '';
end;

function TUCROConn.GetServiceName: String;
begin
  Result := FRemoteService.ServiceName;
end;

function TUCROConn.GetTransObjectName: String;
begin
  Result := '';
end;

procedure TUCROConn.Notification(AComponent: TComponent; Operation: TOperation);
begin
  if (Operation = opRemove) and (AComponent = FRemoteService) then
  begin
    FreeAndNil(FDataAdapter);
    FRemoteService := nil;
  end;
  inherited Notification(AComponent, Operation);
end;

procedure TUCROConn.RefreshROConnection;
begin
  with FRemoteService do
  begin
    FRemoteService.Message := FMessage;
    FRemoteService.Channel := FChannel;
    
    with FDataAdapter do
    begin
      RemoteService := FRemoteService;
      GetSchemaCall.RemoteService := FRemoteService;
      GetDataCall.RemoteService := FRemoteService;
      UpdateDataCall.RemoteService := FRemoteService;
      GetScriptsCall.RemoteService := FRemoteService;
    end;
  end;
end;

procedure TUCROConn.SetChannel(const Value: TROIndyHTTPChannel);
begin
  FChannel := Value;
  RefreshROConnection;
end;

procedure TUCROConn.SetMessage(const Value: TROBinMessage);
begin
  FMessage := Value;
  RefreshROConnection;  
end;

procedure TUCROConn.SetServiceName(const Value: String);
begin
  FRemoteService.ServiceName := Value;
end;

procedure TUCROConn.UCExecSQL(FSQL: String);
var
  ASQL : String;
begin
  ASQL := AnsiToUtf8(FSQL);
  (FRemoteService as IsrvUsuarios).SQLExecuteCommand(ASQL);
end;

function TUCROConn.UCFindDataConnection: Boolean;
begin
  Result := False;
  if Assigned(FRemoteService) then
  begin
    FRemoteService.CheckCanConnect;
    Result := True;
  end;
end;

function TUCROConn.UCFindTable(const Tablename: String): Boolean;
var
  ASchema : TDASchema;
begin
  ASchema := FDataAdapter.ReadSchema;
  try
    Result := Assigned(ASchema.FindDataset(TableName));
  finally
    FreeAndNil(ASchema);
  end;
end;


function TUCROConn.UCGetSQLDataset(FSQL: String): TDataset;
var
  AStream: TMemoryStream;
  ADataStreamer: TDABin2DataStreamer;
  ADataTable: TDACDSDataTable;
begin
  Result := NIL;
  ADataStreamer := TDABin2DataStreamer.Create(NIL);
  AStream := (FRemoteService as IsrvUsuarios).SQLGetData(FSQL, True, -1);

  if AStream <> nil then
  try
    ADataTable := TDACDSDataTable.Create(Application);

    // Generar un nombre aleatorio
    Randomize;
    ADataTable.Name := 'SQLResult' + '_' + IntToStr(Random(MAXINT));

    ADataTable.LocalDataStreamer := ADataStreamer;
    ADataTable.RemoteFetchEnabled := False;
    try
      ADataStreamer.ReadDataset(AStream, ADataTable, True);
      ADataTable.Open;

      { <20><>OJO!! Trapicheo!!!!!
        Forzamos a recuperar en Dataset todas las tuplas
        recorriendonos toda la tabla.}
      ADataTable.Last;
      ADataTable.First;

      Result := ADataTable.Dataset;
    finally
      //FreeAndNIL(ADataTable); <-- No liberar, lo hace Application
    end;
  finally
    FreeAndNIL(AStream);
    FreeAndNIL(ADataStreamer);
  end;
end;

end.