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;
using bsmd.hisnord;

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;
            }

            bool sendSucceeded;

            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);

                    if (core.InitialHIS == Message.NSWProvider.DUDR)
                    {
                        // Rostocker: wir senden alle Nachrichten auf einmal                        
                        sendSucceeded = bsmd.hisnord.Request.Send(messages);

                        if (!sendSucceeded) core.BSMDStatusInternal = MessageCore.BSMDStatus.FAILURE;
                        else core.BSMDStatusInternal = MessageCore.BSMDStatus.SENT;
                        DBManager.Instance.Save(core);
                    }

                    else
                    {

                        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());

                                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;                                   

                                    default:
                                        _log.WarnFormat("Initial HIS not specified for message {0}", message.Id);
                                        break;
                                }

                                if (sendSucceeded)
                                {
                                    // alte Fehlerliste entfernen (die Antwort kann praktisch noch nicht da sein)
                                    // vor dem Versenden zu entfernen halte ich für doof, wenn das Versenden scheitert

                                    foreach (MessageError messageError in message.ErrorList)
                                        DBManager.Instance.Delete(messageError);
                                    foreach (MessageViolation messageViolation in message.ViolationList)
                                        DBManager.Instance.Delete(messageViolation);

                                    _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
            {
                _log.Fatal("database connection failure, stopping service");
                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);            
        }
    }
}