{+----------------------------------------------------------------------------+
 | Filename     TAlertFilter.pas
 | Created:     3.1.2002
 | Author:      Kari Perttula
 | Company:
 | Copyright    ©Gestapo project 2001
 | Description: Sends first alarm received from each location and sensor.
 |              Then collects all alarms received from that particular
 |              location during preset time interval and sends report of
 |              alarms reseived after the first one.
 | Version:     1.0
 | Open Issues:
 +----------------------------------------------------------------------------+}

unit TAlertFilter;

interface
uses Windows,Messages,SysUtils,Classes,shellapi,ExtCtrls,email,TGSMAlert,
     CommunicationClient,helptools;

type TAlarmContainer = class (TObject)
//      Keeps alarmdata from one particular sensor. Knows when last alarm from
//      that sensor has reseived and if timer is active, knows when it was
//      activated.
//      If timer is not active, tells TAlarmFilter to send alarmmessages.
//      Also tells TAlarmFilter to send alarmmessages, when timer goes off.
//      Knows also how many alarms has received since timer has activated.
  private
    sInitTime        : string;
    sLatestAlarmTime : string;
    sLatestAlarm     : string;
    sLocation        : string;
    sSensor          : string;
    sHost            : string;
    sSubject         : string;
    sTo              : string;
    sFrom            : string;
    sResipient       : string;
    sSender          : string;
    nUses            : integer;
    nAlarmCounter    : integer;
    pAlarmInterval   : TTimer;
    GSMALert         : TGSMAlert1;
    Client           : TCommunicationClient;
    { Private declarations }
  protected
    { Protected declarations }
  public 
    constructor Create(AOwner : TComponent; nRepeatInterval : integer;
                     sALocation : string; sASensor : string;
                     sAHost : string; sATo : string; sAFrom : string;
                     sAResipient : string; sASender : string;
                     nAUses : integer);
    procedure ProcessAlarm(sAAlarmTime : string; sAAlarm : string);
    procedure SendAlarm(sAText : string);
    procedure CheckAlarm(Sender : TObject);
    { Public declarations }
  published
    { Published declarations }
end; {TAlarmContainer}

type TAlarmFilter = class (TObject)
// Keeps 2D array of alarmcontainers and directs alarm to right container to
// be processed.
  private
    AlarmQueues     : array of array of TAlarmContainer;
    sLocations      : TStringList;
    sSensors        : TStringList;
    sLocation       : string;
    sSensor         : string;
    sHost           : string;
    sSubject        : string;
    sTo             : string;
    sFrom           : string;
    sResipient      : string;
    sSender         : string;
    { Private declarations }
  protected
    { Protected declarations }
  public
    nRepeatInterval : integer;
    constructor create(AOwner:TComponent; sAHost:string; sASubject:string;
                       sATo:string; sAFrom:string; sAResipient:string;
                       sASender:string; nARepeatInterval:integer;
                       sALocation:string);
                                
    destructor Destroy;  override;
    procedure ProcessAlarm(sALocation : string ; sASensor : string ;
                           sAAlarmTime : string ; sAAlarm : string ;
                           nAUses : integer);
    function CheckLocation() : integer;
    function CheckSensor() : integer;
{ Public declarations }
  published
    { Published declarations }
end; {TAlarmFilter}

implementation

uses
        tAlertController1;


//------------------------------------------------------------------
//                       TAlarmContainer
//------------------------------------------------------------------

constructor TAlarmContainer.Create(AOwner:TComponent; nRepeatInterval:integer;
                             sALocation : string; sASensor : string;
                             sAHost:string; sATo:string;sAFrom:string;
                             sAResipient:string;sASender:string;nAUses:integer);
begin
  inherited Create();
  pAlarmInterval          := TTimer.Create(AOwner);
  pAlarmInterval.Interval := nRepeatInterval*60000;  //1min. = 60000ms.
  pAlarmInterval.OnTimer  := CheckAlarm;
  pAlarmInterval.Enabled  := false;
  sHost                   := sAHost;
  sSubject                := 'Alarm';
  sTo                     := sATo;
  sFrom                   := sATo;
  sResipient              := sAResipient;
  sSender                 := sASender;
  sLocation               := sALocation;
  sSensor                 := sASensor;

end; {Create}
//------------------------------------------------------------------

procedure TAlarmContainer.ProcessAlarm(sAAlarmTime : string; sAAlarm : string);
// If alarm is reseived and timer to collecting alarms is not active: then set
// timer active, set alarm settings and sen alarm. Other vise just set alarm
// settings.
var
  sText : string;
begin
  if pAlarmInterval.Enabled = false then
  begin
    sText := 'At '+sAAlarmTime+' from room '+sLocation+' came alarm : '+
             sSensor+' '+sAAlarm;
    nAlarmCounter := 0;
    pAlarmInterval.Enabled  := true;
    sInitTime := TimeToStr(time);
    sLatestAlarmTime := sAAlarmTime;
    sLatestAlarm := sAAlarm;
    SendAlarm(sText);
  end
  else
  begin
    sLatestAlarmTime := sAAlarmTime;
    sLatestAlarm := sAAlarm;
    nAlarmCounter := nAlarmCounter + 1;
  end;

end; {ProcessAlarm}
//------------------------------------------------------------------

procedure TAlarmContainer.CheckAlarm(Sender : TObject);
//If no new alarms has been received during the last collection intervall, set
//timer off.
//in other case send report and reset timer.
var
  sText : string;
begin
  if nAlarmCounter = 0 then
  begin
    pAlarmInterval.Enabled  := false;
  end
  else
  begin
    sText := 'Sensor '+sSensor+' from room '+sLocation+' have sent '+
        IntToStr(nAlarmCounter)+' alarms since '+sInitTime+
        '. Sensors latest value was: '+sLatestAlarm ;
    pAlarmInterval.Enabled  := true;
    sInitTime := TimeToStr(time);
    sLatestAlarmTime := sInitTime;
    SendAlarm(sText);
    nAlarmCounter := 0;
  end;

end; {CheckAlarm}
//------------------------------------------------------------------

procedure TAlarmContainer.SendAlarm(sAText:string);
// Sends alarms using SMS, EMAIL and/or localdevise
var
  sHost, sSubject, sTo, sFrom :string;
  EMail : TEMail;
begin
  if (nUses and 1) = 1 then         //if UseGSM = True
  begin
    GSMALert.Resipient := sResipient;
    GSMALert.sender := sSender;
    GSMALert.aMessage := sAText;
    GSMALert.SendMessage;
    Client.SendText('DU_AUALARM au_sms_sent ' + DateToStr(Date) + ' ' +                   //tarkista tämä vielä
                     TimeToStr(time)+ ' ' + GSMALert.GetaMessage);
  end;

  if (nUses and 2) = 2 then        //if UseEMail = True
  begin
    EMail := TEMail.create(TComponent(self));
    EMail.QuickSend(sHost, sSubject, sTo, sFrom, sAText);
    EMail.Free;
    Client.SendText('DU_AUALARM au_email_sent ' + DateToStr(Date) + ' ' +                 //tarkista tämä vielä
    TimeToStr(time)+ ' ' + GSMALert.GetaMessage);
  end;

  if (nUses and 4) = 4 then       //if UseLocalAlert = True
  begin
    //TLocalAlert.StartHonking;   // Procedure not implemented
  end;

end; {SendAlarm}
//------------------------------------------------------------------


//------------------------------------------------------------------
//                       TAlarmFilter
//------------------------------------------------------------------

constructor TAlarmFilter.create(AOwner:TComponent; sAHost:string;
                                sASubject:string; sATo:string; sAFrom:string;
                                sAResipient:string; sASender:string;
                                nARepeatInterval:integer; sALocation:string);
begin
  inherited Create;
  sHost           := sAHost;
  sSubject        := sASubject;
  sTo             := sATo;
  sFrom           := sAFrom;
  sResipient      := sAResipient;
  sSender         := sASender;
  sLocation       := sALocation;
  nRepeatInterval := nARepeatInterval;
  sLocations      := TStringList.Create;
  sSensors        := TStringList.Create;
  SetLength(AlarmQueues, 1);
  SetLength(AlarmQueues[0], 1);
end; {create}
//------------------------------------------------------------------

destructor TAlarmFilter.Destroy;
begin
  sLocations.free;
  sSensors.free;
  inherited Destroy;
end; {Destroy}
//------------------------------------------------------------------

procedure TAlarmFilter.ProcessAlarm(sALocation : string ; sASensor : string ;
                                    sAAlarmTime : string ; sAAlarm : string ;
                                    nAUses : integer);
// Finds pointers to location and sensor. using these pointers, creates new
// instance of alarmcontainer (if not already created). And sends alarm to that
// container to be prosessed.
var
  x, y : integer;
begin
  sSensor := sASensor;
 {x := CheckLocation;
  y := CheckSensor;}
  for x := 0 to 3 do
  begin
  for y := 0 to 3 do
  begin



  if AlarmQueues[x,y] = nil then
  begin
    AlarmQueues[x,y] := TAlarmContainer.Create(TComponent(self), nRepeatInterval,
        sALocation, sASensor, sHost, sTo, sFrom, sResipient, sSender, nAUses);
  end;
  AlarmQueues[x,y].ProcessAlarm(sAAlarmTime, sAAlarm);
  end;
  end;

end; {ProcessAlarm}
//------------------------------------------------------------------

function TAlarmFilter.CheckLocation() : integer;
// Checks if any alarms from present location has previously reseived.
// If earlier alarms has not reseived, creates place for holding place for
// pointer to alarmque
var
  nLoc, i : integer;
begin
  result := 0;
  nLoc := sLocations.IndexOf(sLocation);
  if nLoc = -1 then
  begin
    sLocations.add (sLocation);
    nLoc := sLocations.IndexOf(sLocation);
  end;
  result := nLoc;
end; {CheckLocation}
//------------------------------------------------------------------

function TAlarmFilter.CheckSensor() : integer;
// Checks if any alarms from present sensor has previously reseived.
// If earlier alarms has not reseived, creates place for holding place for
// pointer to alarmque
var
  nSen, i :integer;
begin
  result := 0;
  nSen := sSensors.IndexOf(sSensor);
  if nSen = -1 then
  begin
    sSensors.add (sSensor);
    nSen := sSensors.IndexOf(sSensor);
  end;
  result := nSen;
end; {CheckLocation}
//------------------------------------------------------------------

end.