unit ROAction;

interface

uses
  Classes,
  Controls,
  ROConnection,
  GuardianServerServiceLibrary_Intf,
  uROEventRepository,
  Messages,
  Windows,
  DB,
  InvokeRegistry;


type
  TCancellationToken = class
  private
    FIsCancellationRequested: Boolean;
    function GetCancellationRequested: Boolean;
    procedure SetCancellationRequested(const Value: Boolean);
  public
    procedure Reset;
    property IsCancellationRequested: Boolean read GetCancellationRequested write SetCancellationRequested;
  end;

  TROAction = class(TInterfacedObject, IGuardianServerEvents)
  private
    FSessionID: String;
    FROEventReceiver: TROEventReceiver;
    FROConnection: TROConnection;
    FTransaction: TransactionRequestData;
    FResponseMessage: ResponseMessageData;
    FCancellationToken: TCancellationToken;
    FRequestList: RequestMessageArray;
    FRequestComplete: Boolean;
    FRequestTimeout: Boolean;
    FRequestActionTypeData: RequestActionTypeData;
    function GetROConnection: TROConnection;
    function GetRequestList: RequestMessageArray;
    procedure OnSubmitResponse(const ResponseMessage: ResponseMessageData;
      const TransactionMessage: TransactionRequestData);
    function GetActionType: RequestActionTypeData;
    procedure SetActionType(const Value: RequestActionTypeData);
    function GetResponseMesssage: ResponseMessageData;
    procedure SetResponseMessage(const Value: ResponseMessageData);
  public
    constructor Create(ROConnection: TROConnection; CancellationToken: TCancellationToken = nil; CommandTimeout: Integer = DEFAULT_COMMAND_TIMEOUT);
    destructor Destroy; override;
    procedure CancelRequest;
    procedure OpenRequest;
  public
    property RequestList: RequestMessageArray read GetRequestList;
    property ResponseMessage: ResponseMessageData read GetResponseMesssage write SetResponseMessage;
    property ROConnection: TROConnection read GetROConnection;
    property RequestComplete: Boolean read FRequestComplete;
    property RequestTimeout: Boolean read FRequestTimeout;
    property ActionType: RequestActionTypeData read GetActionType write SetActionType;
  end;
implementation

uses
  SysUtils,
  Forms;


{ TROAction }

constructor TROAction.Create(ROConnection: TROConnection; CancellationToken: TCancellationToken = nil; CommandTimeout: Integer = DEFAULT_COMMAND_TIMEOUT);
begin
  _AddRef;

  FROEventReceiver := TROEventReceiver.Create(nil);
  FROEventReceiver.Interval := 0;
  FROEventReceiver.Channel := ROConnection.RORemoteService.Channel;
  FROEventReceiver.Message := ROConnection.RORemoteService.Message;
  FROEventReceiver.ServiceName := ROConnection.RORemoteService.ServiceName;
  FROEventReceiver.RegisterEventHandlers([EID_GuardianServerEvents], [Self]);
  FROEventReceiver.Activate;

  FROConnection := ROConnection;

  FCancellationToken := CancellationToken;
  if Assigned(FCancellationToken) then
    FCancellationToken.Reset;
  FTransaction := TransactionRequestData.Create;
  FTransaction.Timeout := CommandTimeout * 1000;
  FRequestList := FTransaction.Items;
  FRequestComplete := false;
end;

destructor TROAction.Destroy;
begin
  if Assigned(FROEventReceiver) then
  begin
    FROEventReceiver.UnregisterEventHandlers([EID_GuardianServerEvents]);
    FROEventReceiver.Deactivate;
  end;
  FreeAndNil(FTransaction);
  FreeAndNil(FROEventReceiver);
  FreeAndNil(FResponseMessage);
  inherited;
end;

function TROAction.GetActionType: RequestActionTypeData;
begin
  Result := FRequestActionTypeData;
end;

function TROAction.GetRequestList: RequestMessageArray;
begin
  Result := FRequestList;
end;

function TROAction.GetResponseMesssage: ResponseMessageData;
begin
  Result := FResponseMessage;
end;

function TROAction.GetROConnection: TROConnection;
begin
  Result := FROConnection;
end;

procedure TROAction.OpenRequest;
var
  i: Integer;
  start, duration: LongInt;
begin
  if Assigned(ROConnection) then
  begin
    FTransaction.SessionID := ROConnection.GuardianServiceClient.ServiceLogin;
    // if action is not set for transaction get it from first message
    if (FTransaction.MessageType = RequestActionTypeData_None) then
    begin
      if (FTransaction.Items.Count > 0) then
      begin
        FTransaction.MessageType := FTransaction.Items[0].MessageType;
      end;
    end;

    ROConnection.GuardianServiceClient.SubmitTransaction(FTransaction);
    i := 0;
    start := GetTickCount;
    FRequestTimeout := false;
    while ((not RequestComplete) and (not RequestTimeout)) do
    begin
       Inc(i);
       if (i > 20) then
       begin
         duration := GetTickCount - start;
         FRequestTimeout := (duration > (FTransaction.Timeout+500));

         i := 0;
         Application.ProcessMessages;
       end;
    end;
  end;
end;

procedure TROAction.SetActionType(const Value: RequestActionTypeData);
begin
  FRequestActionTypeData := Value;
end;

procedure TROAction.SetResponseMessage(const Value: ResponseMessageData);
begin
  FResponseMessage := ResponseMessageData(Value.Clone());
end;

procedure TROAction.OnSubmitResponse(const ResponseMessage: ResponseMessageData; const TransactionMessage: TransactionRequestData);

begin
  FRequestComplete := (ResponseMessage.Status in [MessageStatusData_Cancelled, MessageStatusData_Error, MessageStatusData_Done]);
  if (FRequestComplete) then
  begin
    if (TransactionMessage.MessageType = RequestActionTypeData_Login) then
      Self.ResponseMessage := LoginResponseData(ResponseMessage)
    else
      Self.ResponseMessage := ResponseMessage
  end;
end;

//procedure TROAction.SetLengthRequestParams(Length: Integer);
//begin
//  SetLength(FRequestParams, Length);
//end;

procedure TROAction.CancelRequest;
begin
//  if Assigned(FSoapActionThread) then
//    FSoapActionThread.CancelRequest;
end;

{ TCancellationToken }

function TCancellationToken.GetCancellationRequested: Boolean;
begin
  Result := FIsCancellationRequested;
end;

procedure TCancellationToken.Reset;
begin
  FIsCancellationRequested := false;
end;

procedure TCancellationToken.SetCancellationRequested(const Value: Boolean);
begin
  FIsCancellationRequested := value;
end;

end.