unit uROMasterServerSessionManager;

{----------------------------------------------------------------------------}
{ RemObjects SDK Library - Core Library                                      }
{                                                                            }
{ compiler: Delphi 5 and up, Kylix 2 and up                                  }
{ platform: Win32, Linux                                                     }
{                                                                            }
{ (c)opyright RemObjects Software. all rights reserved.                      }
{                                                                            }
{ Using this code requires a valid license of the RemObjects SDK             }
{ which can be obtained at http://www.remobjects.com.                        }
{----------------------------------------------------------------------------}

{$I RemObjects.inc}

interface

uses
  Classes, uROClient, uROSessions, uROBinMessage, uROTypes,
  ROMasterServerLibrary_Intf;

type
  { TROMasterServerSessionManager }
  TROMasterServerSessionManager = class(TROCustomSessionManager)
  private
    fBINMessage : TROBinMessage;
    fChannel: TROTransportChannel;
    fSessionManager : IROSessionManager;

    procedure SetChannel(const Value: TROTransportChannel);
    function GetSessionManager: IROSessionManager;

  protected
    procedure  Notification(AComponent: TComponent; Operation: TOperation); override;

    { Overrides }
    function DoFindSession(const aSessionID : TGUID; aUpdateTime: Boolean) : TROSession; override;
    procedure DoDeleteSession(const aSessionID : TGUID; IsExpired : boolean); override;
    procedure DoClearSessions(OnlyExpired : boolean); override;
    function DoGetSessionCount : integer; override;
    procedure DoReleaseSession(aSession : TROSession; NewSession : boolean); override;

    property SessionManager : IROSessionManager read GetSessionManager;
    property OnSessionDeleted;
  public
    constructor Create(aOwner : TComponent); override;
    destructor Destroy; override;
    procedure CheckProperties;
  published
    property Channel : TROTransportChannel read fChannel write SetChannel;

  end;

implementation

uses
  SysUtils, uROClasses, uRORes;

{ TROMasterServerSessionManager }

procedure TROMasterServerSessionManager.CheckProperties;
begin
  Check(Channel = nil, Name + '.Channel must be assigned.');
  Channel.CheckProperties;
end;

constructor TROMasterServerSessionManager.Create(aOwner: TComponent);
begin
  inherited;

  fBINMessage := TROBinMessage.Create(Self);
  // in order to kill checktimer set interval to 0
  Self.SessionCheckInterval := 0;
end;

destructor TROMasterServerSessionManager.Destroy;
begin
  inherited;
end;

procedure TROMasterServerSessionManager.DoClearSessions(
  OnlyExpired: boolean);
begin
  // do nothing
end;

procedure TROMasterServerSessionManager.DoDeleteSession(
  const aSessionID: TGUID; IsExpired: boolean);
begin
  SessionManager.DeleteSession(GUIDToString(aSessionID));
end;

function TROMasterServerSessionManager.DoFindSession(
  const aSessionID: TGUID; aUpdateTime: Boolean): TROSession;
var
  usersession : TROUserSession;
begin
  result := NIL;
  usersession := SessionManager.ReadSession(GUIDToString(aSessionID));
  if (usersession<>NIL) then try
    //result := TROSession.Create(aSessionID);
    result := DoCreateSession(aSessionID);
    result.Created := usersession.Created;
    result.LastAccessed := usersession.LastAccessed;
    result.LoadFromStream(usersession.Data, TRUE);
  finally
    usersession.Free;
  end;
end;

function TROMasterServerSessionManager.DoGetSessionCount: integer;
begin
  result := SessionManager.GetSessionCount;
end;

procedure TROMasterServerSessionManager.DoReleaseSession(
  aSession: TROSession; NewSession: boolean);
var data : Binary;
begin
  data := Binary.Create;
  try
    aSession.SaveToStream(data, TRUE);

    if NewSession
      then SessionManager.CreateSession(GUIDToString(aSession.SessionID), data)
      else SessionManager.UpdateSession(GUIDToString(aSession.SessionID), data);
    aSession.Free();
  finally
    data.Free;
  end;
end;

function TROMasterServerSessionManager.GetSessionManager: IROSessionManager;
begin
  CheckProperties;

  if (fSessionManager=NIL) then begin
    fSessionManager := CoROSessionManager.Create(fBINMessage, fChannel);
  end;

  result := fSessionManager;
end;

procedure TROMasterServerSessionManager.Notification(
  AComponent: TComponent; Operation: TOperation);
begin
  inherited;

  if (Operation<>opRemove) then Exit;

  if (AComponent=fChannel)
    then fChannel := NIL;
end;

procedure TROMasterServerSessionManager.SetChannel(
  const Value: TROTransportChannel);
begin
  if (fChannel=Value) then Exit;

  fChannel := Value;
  fSessionManager := NIL;
  if (fChannel<>NIL) then fChannel.FreeNotification(Self);
end;

end.