program Server;
{$APPTYPE CONSOLE}
uses
  SysUtils,
  Windows,
  ServerFrm in 'ServerFrm.pas' {ServerForm: TDataModule};

{$R *.RES}

var
   ServerForm  : TServerForm;
   HostName, ChannelName : AnsiString;
   Port : Integer;
begin
   if (ParamCount < 3) then
   begin
      WriteLn('This is an Iguana destination plugin.  It runs as a command line application');
      WriteLn('which connects via TCP/IP to the plugin communication server within Iguana.');
      WriteLn('It will be necessary to run a channel in Iguana and set up a channel with');
      WriteLn('a To Plugin component for this to connect to.  See:');
      WriteLn('');
      WriteLn('   http://www.interfaceware.com/manual/plugin_receiving_chameleon_delphi.html');
      WriteLn('');
      WriteLn('Once the channel is set up and running you can connect to it with this usage:');
      WriteLn('');
      WriteLn('  ' + ExtractFileName(ParamStr(0)) + ' <iguana hostname> <plugin communication port> <channel name>');
      WriteLn('');
      WriteLn('The plugin communication port is the port that Iguana listens on for plugin');
      WriteLn('communication.');
      Flush(Output);
      Sleep(12000);
      Halt(0);
   end;
   Hostname     := ParamStr(1);
   Port         := StrToInt(ParamStr(2));
   ChannelName  := ParamStr(3);

   ServerForm := nil;
   try
      try
         ServerForm := TServerForm.Create(nil);
         ServerForm.Run(HostName, Port, ChannelName);
      except
         on E: Exception do
            WriteLn(E.Message);
      end
   finally
      ServerForm.Free;
   end;
end.

unit ServerFrm;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  IGC, CHM, HL7;

type
  TServerForm = class(TDataModule)
    hl7Engine: THL7engine;
    IguanaPlugin: TIGCdestination;
    procedure ProcessMessage(Inputs: IIGCdestinationMessageReceivedEventInputs;
      Outputs: IIGCdestinationMessageReceivedEventOutputs;
      ResubmissionPreview: Boolean); 
    procedure IguanaPluginDisconnected(Sender: TObject);
   procedure hl7EngineMsgPersonUpdate(Sender: TObject; Msg: THL7msgPersonUpdate;
     TransportIndex: Integer);
    procedure hl7EngineLog(Sender: TObject; Line: String);
    procedure hl7EngineParseError(Sender: TObject; MessageData: String;
      TransportIndex: Integer; Description: String; Code: Cardinal);
    procedure IguanaPluginMessageReceived(Sender: TObject;
      Inputs: IIGCdestinationMessageReceivedEventInputs;
      Outputs: IIGCdestinationMessageReceivedEventOutputs);
    procedure IguanaPluginResubmissionPreviewMessageReceived(
      Sender: TObject; Inputs: IIGCdestinationMessageReceivedEventInputs;
      Outputs: IIGCdestinationMessageReceivedEventOutputs);
  private
    { Private declarations }
    FErrorOccured : Boolean;
    FErrorDescription : String;
    FPythonLog : String;
    procedure ClearError;
    function DidErrorOccur : Boolean;
    function ErrorDescription : String;
  public
    { Public declarations }
    procedure Run(HostName : String; Port :Integer; ChannelName : String);
  end;

implementation

{$R *.DFM}

{ TServerForm }

// Error state functions - required to deal with callbacks from the Chameleon Engine instance.
procedure TServerForm.ClearError;
begin
   FErrorOccured := false;
   FPythonLog := '';   // Clear the python log
end;

function TServerForm.DidErrorOccur: Boolean;
begin
   Result := FErrorOccured;
end;

function TServerForm.ErrorDescription: String;
begin
   Result := FErrorDescription;
end;

procedure TServerForm.Run(HostName : String; Port :Integer; ChannelName : String);
begin
   hl7Engine.Load(ExtractFilePath(ParamStr(0)) + 'plugin_receive_test.vmd');
   Write('Connecting to ' + HostName + ':' + IntToStr(Port) + ' for Channel ''' + ChannelName + '''...');
   Flush(Output);
   IguanaPlugin.Connect(HostName, Port, ChannelName);
   WriteLn('Done');
   Flush(Output);
   IguanaPlugin.WaitForDisconnect;
end;

// Message processing invoked by OnMessageReceived and
// OnResubmissionPreviewMessageReceived event handlers.
procedure TServerForm.ProcessMessage(Inputs: IIGCdestinationMessageReceivedEventInputs;
   Outputs: IIGCdestinationMessageReceivedEventOutputs;
   ResubmissionPreview: Boolean);
begin
   // The ResubmissionPreview flag indicates whether or not we're processing a
   // resubmission preview message.  When processing a resubmission preview
   // message, the plugin should simulate the processing that would happen for a
   // regular message, but without causing external side effects.  For example,
   // no database commits should be made for resubmission preview messages.  In
   // this example, regular message processing has no external side effects, so
   // we simply ignore the ResubmissionPreview flag.

   // Message processing goes here. This example just prints the received
   // message and uses the Chameleon engine to parse the message.
   WriteLn('');
   WriteLn('*** Message Received ***');
   WriteLn(AdjustLineBreaks(Inputs.Message));
   Flush(Output);

   // Notice that we 'manually' invoke the parseMessage method on the engine
   // object. This will fire one of the generated onMessage events which are
   // defined in the DestinationPluginEngine class.
   //
   // The plugin classes are not tightly coupled to the HL7Engine object.
   // You can use any kind of transport you like with  Chameleon, including
   // your own transports or third party components.
   //
   // In this application we do not block on events - this is because the
   // plugin components are asynchronous. You can write synchronous
   // applications using Chameleon but you would need to use another
   // transport mechanism other than the plugin components supplied here.
   ClearError();
   hl7Engine.ParseMessage(Inputs.Message, 0);

   // Tell Iguana that the message has been successfully processed.
   Outputs.MessageProcessedFlag := true;

   // You can send additional error/warning/info/debug log messages to Iguana.
   // In this case we simply send an info-level log message containing the
   // Chameleon engine's log output.
   if (Length(FPythonLog) > 0) then
   begin
      Outputs.AddInfoLogMessage(FPythonLog);
   end;

   if (DidErrorOccur) then
   begin
      Outputs.AddErrorLogMessage(ErrorDescription);
   end;
   
   // If the plugin is unable to process the message right away (for example,
   // because the plugin is attempting to communicate with a database that is
   // sometimes unavailable), you can tell Iguana to wait a specified number of
   // milliseconds before resending the message.
   //
   //    Outputs.MessageProcessedFlag := false;
   //    Outputs.ResendMessageFlag := true;
   //    Outputs.ResendMessageDelay := 1000;
   //
   // Or you can tell Iguana to stop the channel and resend the message after
   // the channel is restarted.
   //
   //    Outputs.MessageProcessedFlag := false;
   //    Outputs.ResendMessageFlag := true;
   //    Outputs.StopChannelFlag := true;
   //
   // You can use StopChannel, StopChannelErrorFlag, and StopChannelReason to
   // stop the Iguana channel with or without an error flag, and provide a
   // reason for the stop request.
   //
   //    Outputs.StopChannelFlag := true;
   //    Outputs.StopChannelErrorFlag := true;
   //    Outputs.StopChannelReason := 'An error occurred.';
   //
   // You can send additional error/info/debug log messages to Iguana
   //
   //    Outputs.AddWarningLogMessage('Error log message.');
   //    Outputs.AddInfoMessage('Info log message.');
   //    Outputs.AddDebugMessage('Debug log message.');
end;

// This event is triggered when a message is received from Iguana.
procedure TServerForm.IguanaPluginMessageReceived(Sender: TObject;
   Inputs: IIGCdestinationMessageReceivedEventInputs;
   Outputs: IIGCdestinationMessageReceivedEventOutputs);
begin
   // Note that exceptions can never be thrown outside the handler.
   try
      ProcessMessage(Inputs, Outputs, False);
   except
      on E: Exception do
      begin
         WriteLn(E.Message);
      end;
   end;
end;

// This event is triggered when a resubmission preview message is received from
// Iguana.
procedure TServerForm.IguanaPluginResubmissionPreviewMessageReceived(
   Sender: TObject; Inputs: IIGCdestinationMessageReceivedEventInputs;
   Outputs: IIGCdestinationMessageReceivedEventOutputs);
begin
   // Note that exceptions can never be thrown outside the handler.
   try
      // This handler should simulate the processing that would be performed by
      // the OnMessageReceived event handler without causing external side
      // effects.  For example, database changes should not be made for
      // resubmission preview messages.

      ProcessMessage(Inputs, Outputs, True);
   except
      on E: Exception do
      begin
         WriteLn(E.Message);
      end;
   end;
end;

procedure TServerForm.IguanaPluginDisconnected(Sender: TObject);
begin
   WriteLn('Iguana disconnected from plugin.');
end;

procedure TServerForm.hl7EngineLog(Sender: TObject; Line: String);
begin
   // print statements from within python code in the vmd result in this callback.  We collate
   // the input here so we can log it out via Iguana when the message processing is done.
   FPythonLog := FPythonLog + Line + #13;
end;

// If a parse error occurs we record the error message so we can report this back to Iguana.
procedure TServerForm.hl7EngineParseError(Sender: TObject;
  MessageData: String; TransportIndex: Integer; Description: String;
  Code: Cardinal);
begin
   FErrorOccured := true;
   FErrorDescription := Description;
   WriteLn('Error:');
   WriteLn(Description);
   Flush(Output);
end;

// In this example code we are using the generated stubcode interface to Chameleon.  This
// is one potential choice of interface.  There is also a dynamic interface that one could
// choose to use instead that allows one to dynamically iterate over the tables and their columns.
// See:
// http://www.interfaceware.com/manual/delphi_dynamic_vs_static.html
// for more details.

procedure TServerForm.hl7EngineMsgPersonUpdate(Sender: TObject;
Msg: THL7msgPersonUpdate; TransportIndex: Integer);
begin
   hl7Engine.WriteToLog('Received a PersonUpdate message.');
end;



end.