MARKUS

using System;

using System.Data.Common;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Reflection;

using System.ServiceProcess;

using System.Threading;

using System.Timers;

using MarkusDataModel.Common;

using MarkusDataModel.DataModel;

using MarkusDataModel.DTOs;

using Microsoft.AspNet.SignalR.Client;

using ServiceInterface;

using SignalREngine;

using SignalREngineServiceWindowsService.HubConfig;

using TableDependency;

using TableDependency.EventArgs;

using TableDependency.SqlClient;

namespace SignalREngineServiceWindowsService

{

    class SignalREngineServiceWindowsService : ServiceBase

    {

        #region Default Configuration , Init variable

        /// <summary>

        /// Sql Table Dependency 

        /// </summary>

        private static SqlTableDependency<CONVERTER_DOC> _convertTableDependency;

        private static SqlTableDependency<FINAL_PDF> _finalTableDependency;

        private static string entityConnString = ConnectStringBuilder.MarkusConnectionString().ProviderConnectionString.ToString();

        private static string hubBaseURL = "http://localhost:8089";

        private static string hubName = "MarkusHub";

        private static ConvertSetting convSetting = new ConvertSetting();

        private static FinalSetting finalSetting = new FinalSetting();

        private static DetectedType detectedType = new DetectedType();

        /// <summary>

        /// Logger 

        /// </summary>

        private static ServiceEventLogger _serviceEventLogger = new ServiceEventLogger();

        /// <summary>

        /// Public Constructor for WindowsService.

        /// - Put all of your Initialization code here.

        /// </summary>

        public SignalREngineServiceWindowsService()

        {

            this.ServiceName = "SignalREngineServiceWindowsService";

            this.EventLog.Log = "Application";

            // These Flags set whether or not to handle that specific

            //  type of event. Set to true if you need it, false otherwise.

            this.CanHandlePowerEvent = true;

            this.CanHandleSessionChangeEvent = true;

            this.CanPauseAndContinue = true;

            this.CanShutdown = true;

            this.CanStop = true;

        }

        /// <summary>

        /// Dispose of objects that need it here.

        /// </summary>

        /// <param name="disposing">Whether

        ///    or not disposing is going on.</param>

        protected override void Dispose(bool disposing)

        {

            base.Dispose(disposing);

        }

        /// <summary>

        /// OnStart(): Put startup code here

        ///  - Start threads, get inital data, etc.

        /// </summary>

        /// <param name="args"></param>

        protected override void OnStart(string[] args)

        {

            AllStart_Service();

            base.OnStart(args);

        }

        #endregion

        #region service override method 

        /// <summary>

        /// OnStop(): Put your stop code here

        /// - Stop threads, set final data, etc.

        /// </summary>

        protected override void OnStop()

        {

            //this.timer.Stop();

            //this.timer = null;

            base.OnStop();

        }

        /// <summary>

        /// OnPause: Put your pause code here

        /// - Pause working threads, etc.

        /// </summary>

        protected override void OnPause()

        {

            base.OnPause();

        }

        /// <summary>

        /// OnContinue(): Put your continue code here

        /// - Un-pause working threads, etc.

        /// </summary>

        protected override void OnContinue()

        {

            base.OnContinue();

        }

        /// <summary>

        /// OnShutdown(): Called when the System is shutting down

        /// - Put code here when you need special handling

        ///   of code that deals with a system shutdown, such

        ///   as saving special data before shutdown.

        /// </summary>

        protected override void OnShutdown()

        {

            base.OnShutdown();

        }

        /// <summary>

        /// OnCustomCommand(): If you need to send a command to your

        ///   service without the need for Remoting or Sockets, use

        ///   this method to do custom methods.

        /// </summary>

        /// <param name="command">Arbitrary Integer between 128 & 256</param>

        protected override void OnCustomCommand(int command)

        {

            //  A custom command can be sent to a service by using this method:

            //#  int command = 128; //Some Arbitrary number between 128 & 256

            //#  ServiceController sc = new ServiceController("NameOfService");

            //#  sc.ExecuteCommand(command);

            base.OnCustomCommand(command);

        }

        /// <summary>

        /// OnPowerEvent(): Useful for detecting power status changes,

        ///   such as going into Suspend mode or Low Battery for laptops.

        /// </summary>

        /// <param name="powerStatus">The Power Broadcast Status

        /// (BatteryLow, Suspend, etc.)</param>

        protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)

        {

            return base.OnPowerEvent(powerStatus);

        }

        /// <summary>

        /// OnSessionChange(): To handle a change event

        ///   from a Terminal Server session.

        ///   Useful if you need to determine

        ///   when a user logs in remotely or logs off,

        ///   or when someone logs into the console.

        /// </summary>

        /// <param name="changeDescription">The Session Change

        /// Event that occured.</param>

        protected override void OnSessionChange(

                  SessionChangeDescription changeDescription)

        {

            base.OnSessionChange(changeDescription);

        }

        private void InitializeComponent()

        {

        }

        #endregion

        #region Table Dependency Configuration 

        public static void DependencyRestart()

        {

            TimeSpan _waitTime = TimeSpan.FromSeconds(2);

            ServiceController _watcher = new ServiceController("SignalR_Watcher");

            Process[] watcher = Process.GetProcessesByName("SignalR_Server_Watcher");

            if ( watcher.Length > 0)

            {

                watcher[0].Kill();

                _serviceEventLogger.WriteEventEntry("singalR Server ::: signalr watcher Service kill ", EventLogEntryType.SuccessAudit);

                _watcher.Refresh();

                if ( _watcher.Status == ServiceControllerStatus.Running || _watcher.Status == ServiceControllerStatus.StartPending)

                {

                    _watcher.WaitForStatus(ServiceControllerStatus.Stopped);

                }

                _watcher.Start(new string[] { "Restart" });

                _watcher.WaitForStatus(ServiceControllerStatus.Running);

                _serviceEventLogger.WriteEventEntry("singalR Server ::: signalr watcher Service Restart ", EventLogEntryType.SuccessAudit);

            }

            else

            {

                _serviceEventLogger.WriteEventEntry("singalR Server :::  signalr watcher Service Not Found", EventLogEntryType.Error);

            }

        }

        public static void AllStart_Service()

        {

            ConvertDep();

            FinalDep();

            Startup.StartServer();

            _serviceEventLogger.WriteEventEntry(" AllStart_Service ", EventLogEntryType.SuccessAudit);

        }

        public static void ConvertDep()

        {

            try

            {

                var convertMapper = new ModelToTableMapper<CONVERTER_DOC>();

                convertMapper.AddMapping(s => s.CURRENT_PAGE, "CURRENT_PAGE");

                _convertTableDependency = new SqlTableDependency<CONVERTER_DOC>(entityConnString, "CONVERTER_DOC", convertMapper);

                // Registration Dependency Event 

                _convertTableDependency.OnError += SqlTableDependency_OnError;

                _convertTableDependency.OnChanged += Convert_SqlTableDependency_Changed;

                _convertTableDependency.Start();

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name + " start", EventLogEntryType.SuccessAudit);

            }

            catch (Exception ex)

            {

                _serviceEventLogger.WriteEventEntry("SQL Dependency ERROR " + MethodBase.GetCurrentMethod().Name + " : " + ex.Message, EventLogEntryType.Error);

                DependencyRestart();

                throw;

            }

        }

        public static void FinalDep()

        {

            try

            {

                var finalMapper = new ModelToTableMapper<FINAL_PDF>();

                finalMapper.AddMapping(s => s.CURRENT_PAGE, "CURRENT_PAGE");

                _finalTableDependency = new SqlTableDependency<FINAL_PDF>(entityConnString, "FINAL_PDF", finalMapper);

                _finalTableDependency.OnError += SqlTableDependency_OnError;

                _finalTableDependency.OnChanged += Final_SqlTableDependency_Changed;

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name + " start", EventLogEntryType.SuccessAudit);

                _finalTableDependency.Start();

            }

            catch (Exception ex)

            {

                _serviceEventLogger.WriteEventEntry("SQL Dependency ERROR " + MethodBase.GetCurrentMethod().Name + " : " + ex.Message, EventLogEntryType.Error);

                DependencyRestart();

                throw;

            }

        }

        public static void SqlTableDependency_OnError(object sender, ErrorEventArgs e)

        {

            _serviceEventLogger.WriteEventEntry(" SQL Dependency ERROR " + MethodBase.GetCurrentMethod().Name + " :: " + e.Message, EventLogEntryType.Error);

            DependencyRestart();

            throw e.Error;

        }

        #endregion

        #region Detection change data 

        /// <summary>

        /// 컨버팅 테이블 데이터 변경에 대한 이벤트 감지 메서드 

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        public static void Convert_SqlTableDependency_Changed(object sender, RecordChangedEventArgs<CONVERTER_DOC> e)

        {

            try

            {

                string changeType = e.ChangeType.ToString();

                DetectedMakrusConvertTable(e.ChangeType.ToString(), e.Entity);

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name + " changeType : " + changeType, EventLogEntryType.SuccessAudit);

            }

            catch (Exception ex)

            {

                _serviceEventLogger.WriteEventEntry("Convert_SqlTableDependency_Changed Error : " + ex, EventLogEntryType.Error);

                throw;

            }

        }

        /// <summary>

        /// 파이널 테이블 데이터 변경에 대한 이벤트 감지 메서드 

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        public static void Final_SqlTableDependency_Changed(object sender, RecordChangedEventArgs<FINAL_PDF> e)

        {

            try

            {

                string changeType = e.ChangeType.ToString();

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name + " changeType : " + changeType, EventLogEntryType.SuccessAudit);

                DetectedMakrusFinalTable(changeType, e.Entity);

            }

            catch (Exception ex)

            {

                _serviceEventLogger.WriteEventEntry("Final_SqlTableDependency_Changed Error : " + ex, EventLogEntryType.Error);

                throw;

            }

        }

        #endregion

        #region Markus hub invoke method 

        /// <summary>

        /// 컨버팅 테이블에 대한 허브 invoke 메서드 

        /// </summary>

        /// <param name="type"></param>

        /// <param name="data"></param>

        public static void DetectedMakrusConvertTable(string type, CONVERTER_DOC data)

        {

            using (var hubConn = new HubConnection(hubBaseURL))

            {

                var hub = hubConn.CreateHubProxy(hubName);

                hubConn.Start().Wait();

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name, EventLogEntryType.SuccessAudit);

                if (type == detectedType.DataInsert)

                {

                    hub.Invoke(convSetting.InvokeInsert , data);

                }

                else if (type == detectedType.DataUpdate)

                {

                    hub.Invoke(convSetting.InvokeChange, data);

                }

                else if (type == detectedType.DataDelete)

                {

                    hub.Invoke(convSetting.InvokeDelete, data);

                }

            }

        }

        /// <summary>

        /// 파이널 테이블에 대한 허브 invoke 메서드 

        /// </summary>

        /// <param name="type"></param>

        /// <param name="data"></param>

        public static void DetectedMakrusFinalTable(string type, FINAL_PDF data)

        {

            using (var hubConn = new HubConnection(hubBaseURL))

            {

                var hub = hubConn.CreateHubProxy(hubName);

                hubConn.Start().Wait();

                _serviceEventLogger.WriteEventEntry(MethodBase.GetCurrentMethod().Name, EventLogEntryType.SuccessAudit);

                if (type == detectedType.DataInsert)

                {

                    hub.Invoke(finalSetting.InvokeInsert, data);

                }

                else if (type == detectedType.DataUpdate)

                {

                    hub.Invoke(finalSetting.InvokeChange, data);

                }

                else if (type == detectedType.DataDelete)

                {

                    hub.Invoke(finalSetting.InvokeDelete, data);

                }

            }

        }

        #endregion

    }

}