msgserver.pas

Delphi MsgCommunicator 2-10 component.I ve used, really good job. can be Server-Client message appl

                       const ErrorMessage: String
                       );
   protected
    procedure LoadServerSettings;
    function GetCurrentVersion: String;
    procedure SetActive(Value: Boolean);
    function GetSession(const Client: TMsgClientInfo): TMsgServerSession;
    // Send all the messages stored while the user was off-line
    procedure SendStoredMessagesFromDatabase(Session: TMsgServerSession);
    procedure SendStoredMessages(Session: TMsgServerSession);
    procedure ReceiveMessageToServer(MessageType: TMsgMessageType; SendingDate:  TDateTime; ServerSession: TMsgServerSession; Stream: TMsgMemoryStream);
    procedure ReceiveMessageToUser(UserID: Cardinal; MessageType: TMsgMessageType; SendingDate:  TDateTime; ServerSession: TMsgServerSession; Stream: TMsgMemoryStream);
    procedure ReceiveMessage(ServerSession: TMsgServerSession; Buffer: PChar; Size: Integer);
    function CompareUsers(
                      const UserInfo1: TMsgUserInfo;
                      const UserInfo2: TMsgUserInfo;
                      SortBy:          TMsgUserInfoArraySortBy;
                      Ascending:       Boolean): Integer;
   public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure GetUsers(
                       var Users: TMsgUserInfoArray;
                       const SortBy: TMsgUserInfoArraySortBy = msgusbNone;
                       const Ascending: Boolean = True
                      );
    procedure SortUsers(
                          var Users:        TMsgUserInfoArray;
                          const SortBy:     TMsgUserInfoArraySortBy;
                          const Ascending:  Boolean = True
                       );
    procedure GetClients(var Clients: TMsgClientInfoArray);
    // fills Users with user information records if some users were found
    procedure FindUsers(
                    var Users:                    TMsgUserInfoArray;
                    var UserNameComparison:       TMsgTextComparison;
                    var FirstNameComparison:      TMsgTextComparison;
                    var LastNameComparison:       TMsgTextComparison;
                    var OrganizationComparison:   TMsgTextComparison;
                    var DepartmentComparison:     TMsgTextComparison;
                    var ApplicationComparison:    TMsgTextComparison;
                    var HostComparison:           TMsgTextComparison;
                    var PortComparison:           TMsgIntegerComparison;
                    Status:                       TMsgUserStatus = msgNone;
                    UserID:                       Cardinal = MSG_INVALID_USER_ID;
                    UserName:                     String = '';
                    FirstName:                    String = '';
                    LastName:                     String = '';
                    Organization:                 String = '';
                    Department:                   String = '';
                    Host:                         String = '';
                    Application:                  String = '';
                    SearchCondition:              String = ''; // SQL WHERE clause without word WHERE
                    // ORDER BY columns without ORDER BY words
                    // example: SenderID DESC, SendingDate ASC
                    SortBy:                       TMsgUserInfoArraySortBy = msgusbNone;
                    Ascending:                    Boolean = True;
                    OrderByClause:                String = ''
                       );
   // return new query object with found messages from MsgMessages table
   function FindMessages(
                         const MessageTextComparison:         TMsgTextComparison;
                         const MessageUnicodeTextComparison:  TMsgTextComparison;
                         const SendingDate:                   TMsgDateComparison;
                         const DeliveryDate:                  TMsgDateComparison;
                         const SearchDelivered:               Boolean;
                         const Delivered:                     Boolean = True;
                         const MessageText:         String = ''; // text of the message
                         const MessageUnicodeText:  WideString = ''; // unicode text of the message
                         const SenderID:            Cardinal = MSG_INVALID_USER_ID;
                         const RecipientID:         Cardinal = MSG_INVALID_USER_ID;
                         const MessageType:         TMsgMessageType = aamtNone;
                         const MessageDataSize:     Integer = -1; // size of MessageData
                         const OrderBySendingDate:  Boolean = False;
                         // ORDER BY columns without ORDER BY statement
                         // example: SenderID DESC, SendingDate ASC
                         const OrderByClause:       String = '';
                         const Command:             Cardinal = 0 // no condition on command field if TMsgMessageType = aamtNone
                        ): TDataset;
    function SendMessage(ToUserID: Cardinal; const Text: String): Integer; overload;
    function SendMessage(ToUserID: Cardinal; Buffer: PChar; Size: Integer): Integer; overload;
    function SendMessage(ToUserID: Cardinal; Stream: TStream): Integer; overload;
    function SendCommand(
                                ToUserID: Cardinal;
                                Command:  Cardinal;
                                Buffer:   PChar;
                                Size:     Integer
                                        ): Integer;
   public
    property ConnectionManager: TMsgServerConnectionManager read FConnectionManager;
    property LocalHost: String read GetLocalHost;
    property LocalPort: Integer read GetLocalPort;
    property CryptoParams: TMsgCryptoParamsEditor read FCryptoParamsEditor write FCryptoParamsEditor;
    property NetworkSettings: TMsgServerNetworkSettingsEditor read GetNetworkSettings; // For compatibility with Accuracer Connection unit
   published
    property Database: TMsgDatabase read FDatabase write FDatabase;
    property TempTable: TMsgTempTable read FTempTable write FTempTable;
    property MaxConnections: Integer read GetMaxConnections write FMaxConnections;
    property Active: Boolean read FActive write SetActive;
    property CurrentVersion: String read GetCurrentVersion write FCurrentVersion;
    property ConfigFileName: String read FConfigFileName write FConfigFileName;
    property DataPath: String read FDataPath write FDataPath;
    property ConnectionParams: TMsgServerConnectParamsEditor read FConnectionParams write FConnectionParams;

// Start/Stop
    property BeforeServerStart: TNotifyEvent read FBeforeServerStart write FBeforeServerStart;
    property AfterServerStart: TNotifyEvent read FAfterServerStart write FAfterServerStart;
    property BeforeServerStop: TNotifyEvent read FBeforeServerStop write FBeforeServerStop;
    property AfterServerStop: TNotifyEvent read FAfterServerStop write FAfterServerStop;

// Connect/Disconnect
    property AfterConnect: TNotifyEvent read FAfterConnect write FAfterConnect;
    property BeforeConnect: TNotifyEvent read FBeforeConnect write FBeforeConnect;
    property AfterDisconnect: TNotifyEvent read FAfterDisconnect write FAfterDisconnect;
    property BeforeDisconnect: TNotifyEvent read FBeforeDisconnect write FBeforeDisconnect;

    property ServerID: Integer read FServerID write SetServerID;
    property StoreMessageHistory: Boolean read FStoreMessageHistory write FStoreMessageHistory;

    property MinUserID: Cardinal read FMinUserID write FMinUserID;

    property UseConfigFile: Boolean read FUseConfigFile write FUseConfigFile;

// Receive Message
    property OnReceiveTextMessage: TMsgOnReceiveTextMessage read FOnReceiveTextMessage write FOnReceiveTextMessage;
    property OnReceiveBinaryMessage: TMsgOnReceiveBinaryMessage read FOnReceiveBinaryMessage write FOnReceiveBinaryMessage;
    property OnReceiveStreamMessage: TMsgOnReceiveStreamMessage read FOnReceiveStreamMessage write FOnReceiveStreamMessage;
    property OnReceiveCommand: TMsgOnReceiveCommand read FOnReceiveCommand write FOnReceiveCommand;

// Server properties
    property OnUserRegistered: TMsgOnUserRegistered read FOnUserRegistered write FOnUserRegistered;
    property OnUserInfoChanged: TMsgOnUserInfoChanged read FOnUserInfoChanged write FOnUserInfoChanged;

  end; // TMsgServer



 function InstallingService: Boolean;
 function InteractiveService: Boolean;


implementation

{$IFDEF TRIAL_VERSION}
uses
  MsgCommunicator, Math;
{$ENDIF}



////////////////////////////////////////////////////////////////////////////////
//
// TMsgServerNetworkSettingsEditor
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// Create
//------------------------------------------------------------------------------
constructor TMsgServerNetworkSettingsEditor.Create;
begin
  inherited Create;
  FServerReceiveTimeOut := MsgServerReceiveTimeOut;
  FServerReceiveSleep := MsgServerReceiveSleep;
  FMinServerSendTimeOut := MsgMinServerSendTimeOut;
  FServerSendTimeOut := MsgServerSendTimeOut;
  FServerWaitForSendSleep := MsgServerWaitForSendSleep;
  FServerResendDelay := MsgServerResendDelay;
  FServerRequestDelay := MsgServerRequestDelay;
  FWaitForMessagesSend := MsgWaitForMessagesSend;
  FWaitForServerSessionThreadTimeOut := MsgWaitForServerSessionThreadTimeOut; 
  FServerThreadsTerminateDelay := MsgServerThreadsTerminateDelay;
  FServerSessionTerminatorSleep := MsgServerSessionTerminatorSleep;
  FWaitForPingAnswer := MsgWaitForPingAnswer;
  FPingClients := MsgPingClients;
  FServerPingSleep := MsgServerPingSleep;
end; // Create


//------------------------------------------------------------------------------
// Destroy
//------------------------------------------------------------------------------
destructor TMsgServerNetworkSettingsEditor.Destroy;
begin
  inherited Destroy;
end; // Destroy


//------------------------------------------------------------------------------
// Assign
//------------------------------------------------------------------------------
procedure TMsgServerNetworkSettingsEditor.Assign(Source: TPersistent);
begin
  if (Source <> nil) then
   if (Source is TMsgServerNetworkSettingsEditor) then
    begin
      inherited Assign(Source);
      FServerReceiveTimeOut := TMsgServerNetworkSettingsEditor(Source).ServerReceiveTimeOut;
      FServerReceiveSleep := TMsgServerNetworkSettingsEditor(Source).ServerReceiveSleep;
      FMinServerSendTimeOut := TMsgServerNetworkSettingsEditor(Source).MinServerSendTimeOut;
      FServerSendTimeOut := TMsgServerNetworkSettingsEditor(Source).ServerSendTimeOut;
      FServerWaitForSendSleep := TMsgServerNetworkSettingsEditor(Source).ServerWaitForSendSleep;
      FServerResendDelay := TMsgServerNetworkSettingsEditor(Source).ServerResendDelay;
      FServerRequestDelay := TMsgServerNetworkSettingsEditor(Source).ServerRequestDelay;
      FWaitForMessagesSend := TMsgServerNetworkSettingsEditor(Source).WaitForMessagesSend;
      FWaitForServerSessionThreadTimeOut := TMsgServerNetworkSettingsEditor(Source).WaitForServerSessionThreadTimeOut;
      FServerThreadsTerminateDelay := TMsgServerNetworkSettingsEditor(Source).ServerThreadsTerminateDelay;
      FServerSessionTerminatorSleep := TMsgServerNetworkSettingsEditor(Source).ServerSessionTerminatorSleep;
      FPingClients := TMsgServerNetworkSettingsEditor(Source).PingClients;
      FWaitForPingAnswer := TMsgServerNetworkSettingsEditor(Source).WaitForPingAnswer;
      FServerPingSleep := TMsgServerNetworkSettingsEditor(Source).ServerPingSleep;
    end;
end; // Assign


//------------------------------------------------------------------------------
// Copy ServerNetwork settings to ConnectParams
//------------------------------------------------------------------------------
procedure TMsgServerNetworkSettingsEditor.CopySettingsToConnectParams(var ConnectParams: TMsgConnectParams);
begin
  inherited CopySettingsToConnectParams(ConnectParams);
  ConnectParams.ServerReceiveTimeOut := FServerReceiveTimeOut;
  ConnectParams.ServerReceiveSleep := FServerReceiveSleep;
  ConnectParams.MinServerSendTimeOut := FMinServerSendTimeOut;
  ConnectParams.ServerSendTimeOut := FServerSendTimeOut;
  ConnectParams.ServerWaitForSendSleep := FServerWaitForSendSleep;
  ConnectParams.ServerResendDelay := FServerResendDelay;
  ConnectParams.ServerRequestDelay := FServerRequestDelay;
  ConnectParams.WaitForMessagesSend := FWaitForMessagesSend;
  ConnectParams.WaitForServerSessionThreadTimeOut := FWaitForServerSessionThreadTimeOut;
  ConnectParams.ServerThreadsTerminateDelay := FServerThreadsTerminateDelay;
  ConnectParams.ServerSessionTerminatorSleep := FServerSessionTerminatorSleep;
  ConnectParams.PingClients := FPingClients;
  ConnectParams.WaitForPingAnswer := FWaitForPingAnswer;
  ConnectParams.ServerPingSleep := FServerPingSleep;
end; // CopySettingsToConnectParams



////////////////////////////////////////////////////////////////////////////////
//
// TMsgServerConnectParamsEditor
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
constructor TMsgServerConnectParamsEditor.Create;
begin
  inherited;
  LocalPort := MsgDefaultServerPort;
  FNetworkSettings := TMsgServerNetworkSettingsEditor.Create;
end;//Create


//------------------------------------------------------------------------------
// Destroy
//------------------------------------------------------------------------------
destructor TMsgServerConnectParamsEditor.Destroy;
begin
  FNetworkSettings.Free;
  inherited;
end; // Destroy


//------------------------------------------------------------------------------
// Assign
//------------------------------------------------------------------------------
procedure TMsgServerConnectParamsEditor.Assign(Source: TPersistent);
begin
  if (Source <> nil) then
   if (Source is TMsgConnectionParamsEditor) then
    begin
     inherited Assign(Source);
     FNetworkSettings.Assign(TMsgServerConnectParamsEditor(Source).NetworkSettings);
    end;
end; // Assign


//------------------------------------------------------------------------------
// return ConnectParams
//------------------------------------------------------------------------------
function TMsgServerConnectParamsEditor.GetConnectParams: TMsgConnectParams;
begin
  Result := inherited GetConnectParams;
  FNetworkSettings.CopySettingsToConnectParams(Result);
end; // GetConnectParams


////////////////////////////////////////////////////////////////////////////////
//
// TMsgServerSession
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// Create
//------------------------------------------------------------------------------
constructor TMsgServerSession.Create(aServer: TComponent);