git_bsmd/nsw/Source/SendNSWMessageService/NSWSendService.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.IO;
using System.ServiceProcess;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using log4net;

using bsmd.database;
using bsmd.dbh;



namespace SendNSWMessageService
{
    public partial class NSWSendService : ServiceBase
    {
        private Timer _timer;
        private object _timerlock = new object();
        private bool processRunning = false;
        private ILog _log = LogManager.GetLogger(typeof(NSWSendService));

        public NSWSendService()
        {
            Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            this.EventLog.Source = this.ServiceName;
            this.EventLog.Log = "Application";            
            this.Init(args);
            this.EventLog.WriteEntry("NSW Send Service started.", EventLogEntryType.Information);
            this.DoOnce();
        }

        public void Init(string[] args)
        {
            this._timer = new Timer();
            this._timer.Interval = Properties.Settings.Default.SleepSeconds * 1000;
            this._timer.Elapsed += _timer_Elapsed;
            this._timer.Enabled = true;            
        }

        public void DoOnce()
        {
            this._timer_Elapsed(null, null);
        }

        void _timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            lock (this._timerlock)
            {
                if (this.processRunning) return;
                else this.processRunning = true;
            }

            if (DBManager.Instance.Connect(Properties.Settings.Default.ConnectionString))
            {

                // Datenbank auf zu sendende Objekte überprüfen und laden                
                                
                List<MessageCore> coresMarkedForSending = DBManager.Instance.GetMessageCoresByStatus(MessageCore.BSMDStatus.TOSEND);

                foreach (MessageCore core in coresMarkedForSending)
                {

                    List<Message> messages = DBManager.Instance.GetMessagesForCore(core);

                    List<Message> toSendMessageList = new List<Message>();

                    if ((core.IsTransit && core.TransitId.IsNullOrEmpty()) ||
                        (!core.IsTransit && core.VisitId.IsNullOrEmpty()))
                    {
                        foreach (Message message in messages)
                        {
                            if((message.MessageNotificationClass == Message.NotificationClass.VISIT) ||
                                (message.MessageNotificationClass == Message.NotificationClass.TRANSIT))
                            {
                                if((message.InternalStatus == Message.BSMDStatus.UNDEFINED) || 
                                    (message.InternalStatus == Message.BSMDStatus.PREPARE) ||
                                    (message.InternalStatus == Message.BSMDStatus.TOSEND))
                                {
                                    if (message.HIS == Message.NSWProvider.UNDEFINED)
                                        message.HIS = core.InitialHIS;
                                    toSendMessageList.Add(message);
                                }
                            }
                        }
                    }
                    else // eine VISIT/TRANSIT Id ist vorhanden, die Daten können gesendet werden
                    {
                        // versendet werden nur die Nachrichten, die den Status "UNDEFINED", "PREPARE" und "TOSEND" haben 
                        // diese wurden entweder von EU-NOAD angelegt oder durch den Melder bearbeitet
                        // Wichtig ist eine erfolgreich versendete Meldung nicht erneut zu versenden
                        foreach (Message message in messages)
                        {
                            if ((message.InternalStatus == Message.BSMDStatus.UNDEFINED) ||
                                (message.InternalStatus == Message.BSMDStatus.PREPARE) ||
                                (message.InternalStatus == Message.BSMDStatus.TOSEND))
                            {
                                if (message.HIS == Message.NSWProvider.UNDEFINED)
                                    message.HIS = core.InitialHIS;

                                toSendMessageList.Add(message);
                            }
                        }
                    }

                    foreach (Message message in toSendMessageList)
                    {
                        try
                        {
                            _log.InfoFormat("Sending {0} message to {1}",
                                message.MessageNotificationClass.ToString(), message.HIS.ToString());

                            bool sendSucceeded = false;
                            // switch über passendes HIS / Schnittstelle
                            switch (message.HIS)
                            {
                                case Message.NSWProvider.DBH:
                                    sendSucceeded = bsmd.dbh.Request.SendMessage(message);
                                    if (!sendSucceeded)
                                    {
                                        message.InternalStatus = Message.BSMDStatus.SEND_FAILED;
                                    }
                                    break;
                                case Message.NSWProvider.DAKOSY:
                                    sendSucceeded = bsmd.dakosy.Request.Send(message);
                                    if (!sendSucceeded) message.InternalStatus = Message.BSMDStatus.SEND_FAILED;
                                    break;

                                case Message.NSWProvider.DUDR:
                                    _log.Warn("Cannot send via Daten und Dienste HRO yet");
                                    break;
                                default:
                                    _log.WarnFormat("Initial HIS not specified for message {0}", message.Id);
                                    break;
                            }

                            if (sendSucceeded)
                            {
                                _log.Info("send successful, saving message.");
                                message.InternalStatus = Message.BSMDStatus.SENT;
                                message.SentAt = DateTime.Now;                                
                            }

                            DBManager.Instance.Save(message);

                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("SENDING message {0}: {1}", message.Id.ToString(), ex.Message);
                        }
                    }                   
                }

                DBManager.Instance.Disconnect();

            }
            else
            {
                this.EventLog.WriteEntry("NSW Send Service stopped: DB connection failed", EventLogEntryType.Error);
                this.Stop();
            }

            lock (this._timerlock)
            {
                this.processRunning = false;
            }
            
        }

        protected override void OnPause()
        {
            this._timer.Stop();            
        }

        protected override void OnContinue()
        {
            this._timer.Start();            
        }

        protected override void OnStop()
        {
            this._timer.Enabled = false;
            this.EventLog.WriteEntry("NSW Send Service stopped.", EventLogEntryType.Information);            
        }
    }
}