MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

using System.Web;

using Microsoft.AspNet.SignalR;

using SignalREngine.Dto;

using Microsoft.AspNet.SignalR.Hubs;

using MarkusDataModel.DataModel;

using MarkusDataModel.Common;

using MarkusDataModel.DTOs;

using TableDependency.SqlClient;

using TableDependency.EventArgs;

using static ServiceInterface.LogView_Interface;

using ServiceInterface;

using System.Reflection;

using System.Diagnostics;

using TableDependency;

using IKCOM;

namespace SignalREngine

{

    [HubName("MarkusHub")]

    public class MyHub : Hub

    {

        #region Real Time Transport Data 

        private ServiceEventLogger _serviceEventLogger;

        public MyHub()

        {

            _serviceEventLogger = new ServiceEventLogger();

        }

        #region Entity Method 

        /// <summary>

        /// PDF status 가져오기

        /// </summary>

        /// <returns></returns>

        public List<StatusDTO> GetPdfStatus()

        {

            using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

            {

                return ent.PROPERTIES

                    .Where(p => p.TYPE == "PDFStatus")

                    .Select(ret => new StatusDTO()

                    {

                        ID = ret.ID,

                        Property = ret.PROPERTY,

                        Type = ret.TYPE,

                        Value = ret.VALUE

                    }).ToList();

            }

        }

        /// <summary>

        /// 프로젝트 리스트 가져오기

        /// </summary>

        /// <param name="projNo"></param>

        /// <param name="pType"></param>

        /// <returns></returns>

        public IEnumerable<RunProjectsList> ProjectList(string projNo, string pType)

        {

            List<RunProjectsList> ConvertProjectList = new List<RunProjectsList>();

            GET_PROJECT_TYPE getProjType = new GET_PROJECT_TYPE();

            using (markusEntities entity = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

            {

                // 실행 프로젝트에 대해서 가져옴 ( IsActivity 가 1 인 프로젝트 ) 

                var runProject = entity

                .RUN_PROJECTS

                .Where(run => run.IS_ACTIVITY.Equals(1) && run.PROJECT_NO == projNo)

                .OrderBy(order => order.RUN_DATETIME)

                .ToList();

                if (runProject.Count > 0)

                {

                    // 프로젝트 리스트 불러오기 

                    var projectList = runProject.Select(ret => new RunProjectsList()

                    {

                        ProjectNO = ret.PROJECT_NO,

                        ProjectName = ret.PROJECT_NAME,

                        RunDateTime = ret.RUN_DATETIME,

                        IsActivity = ret.IS_ACTIVITY

                    }).ToList();

                    projectList.ForEach(proj =>

                    {

                        var statusCount = (pType == getProjType.Convert) ?

                            entity.CONVERTER_DOC

                            .Where(cd => cd.PROJECT_NO == proj.ProjectNO)

                            .GroupBy(g => g.STATUS).OrderBy(g => g.Key)

                            .Select(docStatus => new ConvertingStatus()

                            {

                                Key = docStatus.Key,

                                Count = docStatus.Count(),

                            })

                            :

                            entity.FINAL_PDF

                             .Where(cd => cd.PROJECT_NO == proj.ProjectNO)

                             .GroupBy(g => g.STATUS)

                             .OrderBy(g => g.Key)

                             .Select(docStatus => new ConvertingStatus()

                             {

                                 Key = docStatus.Key,

                                 Count = docStatus.Count(),

                             });

                        // Status 별로 분류

                        statusCount.ToList().ForEach(stat =>

                        {

                            switch (stat.Key)

                            {

                                case (int)PDFStatus.Insert:

                                    proj.Insert = stat.Count;

                                    break;

                                case (int)PDFStatus.Wait:

                                    proj.Wait = stat.Count;

                                    break;

                                case (int)PDFStatus.Crop:

                                    proj.Crop = stat.Count;

                                    break;

                                case (int)PDFStatus.Success:

                                    proj.Success = stat.Count;

                                    break;

                                case (int)PDFStatus.Error:

                                    proj.Error = stat.Count;

                                    break;

                            }

                            proj.Entire += stat.Count;

                        });

                        ConvertProjectList.Add(proj);

                    });

                }

            }

            return ConvertProjectList;

        }

        #endregion

        #region Project Broadcast

        /// <summary>

        /// 프로젝트 리스트 보내기

        /// </summary>

        /// <param name="ProjectNO"></param>

        /// <param name="pType"></param>

        /// <returns></returns>

        [HubMethodName("GetProjectList")]

        public void GetProjectList(string ProjectNO, string pType)

        {

            Clients.All.UpdateProjectList(ProjectList(ProjectNO, pType), pType);

        }

        #endregion

        #region Convert Broadcast

        /// <summary>

        /// Insert 

        /// </summary>

        /// <returns></returns>

        public void BroadcastConvertTableInserted(CONVERTER_DOC InsertConvertData)

        {

            try

            {

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

                Clients.All.BroadcastConvertTableInserted(InsertConvertData, GetPdfStatus());

            }

            catch (Exception)

            {

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

                throw;

            }

        }

        /// <summary>

        /// Change

        /// </summary>

        /// <param name="changedConvertData"></param>

        /// <returns></returns>

        public void BroadcastConvertTableChanged(CONVERTER_DOC changedConvertData)

        {

            try

            {

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

                Clients.All.BroadcastConvertTableChanged(changedConvertData, GetPdfStatus());

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

        /// <summary>

        /// Delete

        /// </summary>

        /// <param name="deletedConvertData"></param>

        /// <returns></returns>

        public void BroadcastConvertTableDeleted(CONVERTER_DOC deletedConvertData)

        {

            try

            {

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

                Clients.All.BroadcastConvertTableDeleted(deletedConvertData);

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

        #endregion

        #region Final Broadcast 

        /// <summary>

        /// Insert

        /// </summary>

        /// <returns></returns>

        public void BroadcastMergeTableInserted(FINAL_PDF InsertData)

        {

            try

            {

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

                Clients.All.BroadcastMergeTableInserted(InsertData, GetPdfStatus());

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

        /// <summary>

        /// Change

        /// </summary>

        /// <param name="changeFinalData"></param>

        /// <returns></returns>

        public void BroadcastMergeTableChanged(FINAL_PDF changeFinalData)

        {

            try

            {

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

                Clients.All.BroadcastMergeTableChanged(changeFinalData, GetPdfStatus());

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

        /// <summary>

        /// Delete

        /// </summary>

        /// <param name="DeletedFinalData"></param>

        /// <returns></returns>

        public void BroadcastMergeTableDeleted(FINAL_PDF DeletedFinalData)

        {

            try

            {

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

                Clients.All.BroadcastMergeTableDeleted(DeletedFinalData);

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

        #endregion

        #region hub override method 

        // hub disconnected

        public override Task OnDisconnected(bool stopCalled)

        {

            try

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.SuccessAudit);

                if (stopCalled)

                {

                    Console.WriteLine(String.Format("Client {0} explicitly closed the connection.", Context.ConnectionId));

                }

                else

                {

                    Console.WriteLine(String.Format("Client {0} timed out .", Context.ConnectionId));

                }

                return base.OnDisconnected(stopCalled);

            }

            catch (Exception)

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.Error);

                throw;

            }

        }

        public override Task OnConnected()

        {

            // Add your own code here.

            // For example: in a chat application, record the association between

            // the current connection ID and user name, and mark the user as online.

            // After the code in this method completes, the client is informed that

            // the connection is established; for example, in a JavaScript client,

            // the start().done callback is executed.

            try

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.SuccessAudit);

                return base.OnConnected();

            }

            catch (Exception)

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.Error);

                throw;

            }

        }

        public override Task OnReconnected()

        {

            // Add your own code here.

            // For example: in a chat application, you might have marked the

            // user as offline after a period of inactivity; in that case 

            // mark the user as online again.

            try

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.SuccessAudit);

                return base.OnReconnected();

            }

            catch (Exception)

            {

                _serviceEventLogger.WriteEventEntry((MethodBase.GetCurrentMethod().Name + ", connection ID :" + Context.ConnectionId), EventLogEntryType.Error);

                throw;

            }

        }

        #endregion

        #endregion

    }

    [HubName("MarkusLicenseHub")]

    public class MarkusLicenseHub : Hub

    {

        LICENSE_COMMENT _COMMENT = new LICENSE_COMMENT();

        #region Markus Usage History Stamp

        /// <summary>

        /// Markus 공지사항 전달 

        /// </summary>

        /// <param name="msg"></param>

        public void MarkusNotification(string msg)

        {

            Clients.All.MarkusNotification(msg);

        }

        /// <summary>

        /// Markus 프로그램에 접속하였을 때 로그 기록

        /// </summary>

        /// <param name="userID"></param>

        /// <param name="userName"></param>

        public int ConnectionMarkus(string userID, string userName)

        {

            #region 접속 기록 

            // 해당 사용자가 라이센스 이용자로 등록되어 있는지 확인.

            using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

            {

                MEMBER connectionUser = ent.MEMBER

                    .Where(mem => mem.ID == userID && mem.NAME == userName)

                    .FirstOrDefault();

                if (connectionUser != null)

                {

                    return ConnectionStamp(connectionUser, Context.ConnectionId);

                }

                else

                {

                    return 404;

                }

            }

            #endregion

        }

        /// <summary>

        /// 다른기기 강제종료 하고 접속할려고 할때 해당 기기 로그 기록하고 다른기기에는 강제종료 메세지 전달 

        /// </summary>

        /// <param name="userID"></param>

        /// <param name="userName"></param>

        /// <returns></returns>

        public bool ForceConnectionMarkus(string userID, string userName)

        {

            #region 다른기기 강제종료 하고 접속할려고 할때 해당 기기 로그 기록하고 다른기기에는 강제종료 메세지 전달 

            try

            {

                using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

                {

                    var lastConnectionLog = ent.LICENSE_LOG

                        .Where(fil => fil.USER_ID == userID && fil.USER_NAME == userName && fil.STATUS == (int)MARKUS_CONNECTION_TYPE.PROCESSING)

                        .OrderByDescending(order => order.EVENT_TIME)

                        .FirstOrDefault();

                    if (lastConnectionLog != null)

                    {

                        //using (CloudMarkusCIEntities entity = new CloudMarkusCIEntities(ConnectStringBuilder.ProjectCIConnectString("000000").ToString()))

                        //{

                        //    MEMBER connectionUser = entity.MEMBER

                        //        .Where(mem => mem.ID == userID && mem.NAME == userName)

                        //        .FirstOrDefault();

                        //    if (connectionUser != null)

                        //    {

                        //        ForceConnectionStamp(connectionUser, Context.ConnectionId);

                        //        Clients.Client(lastConnectionLog.CONNECTION_ID).ForceTerminate(true);

                       return true;

                        //    }

                        //    else

                        //    {

                        //        return false;

                        //    }

                        //}

                    }

                    else

                    {

                        return false;

                    }

                }

            }

            catch (Exception)

            {

                throw;

            }

            #endregion

        }

        /// <summary>

        /// 프로그램을 정상적으로 종료하였을 때 로그 기록

        /// </summary>

        /// <param name="userID"></param>

        /// <param name="userName"></param>

        public void DisConnectionMarkus()

        {

            #region 종료 기록 

            try

            {

                Clients.Caller.DisconnectionMarkus(DisConnectionStamp(Context.ConnectionId));

            }

            catch (Exception)

            {

                throw;

            }

            #endregion

        }

        /// <summary>

        /// Force Connection Stamp

        /// </summary>

        /// <param name="connUser"></param>

        /// <returns></returns>

        public bool ForceConnectionStamp(MEMBER connUser, string connectionID)

        {

            #region Force Connection Stamp Method 

            try

            {

                using (markusEntities logEnt = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

                {

                    LICENSE_LOG log = new LICENSE_LOG()

                    {

                        USER_ID = connUser.ID,

                        USER_NAME = connUser.NAME,

                        CONNECTION_ID = connectionID,

                        EVENT_TIME = DateTime.Now,

                        STATUS = (connUser.ISLICENSE == (int)LICENSE_TYPE.INACTIVE) ? (int)MARKUS_CONNECTION_TYPE.REJECT : (int)MARKUS_CONNECTION_TYPE.PROCESSING, // ** 2 인 경우는 "거부" 로 표시 

                        DESCRIPTION = (connUser.ISLICENSE == (int)LICENSE_TYPE.ACTIVE) ? _COMMENT.forceConnection : _COMMENT.reject // ** 

                    };

                    logEnt.LICENSE_LOG.AddObject(log);

                    logEnt.SaveChanges();

                    return (connUser.ISLICENSE == (int)LICENSE_TYPE.ACTIVE) ? true : false;

                }

            }

            catch (Exception)

            {

                throw;

            }

            #endregion

        }

        /// <summary>

        /// Connection Stamp

        /// </summary>

        /// <param name="connUser"></param>

        /// <param name="connectionID"></param>

        /// <returns></returns>

        public int ConnectionStamp(MEMBER connUser, string connectionID)

        {

            #region Connection Stamp Method 

            try

            {

                using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

                {

                    DateTime filDate = DateTime.Now.AddMonths(-1);

                    var currentLog = ent.LICENSE_LOG

                        .Where(fil => fil.USER_ID == connUser.ID && fil.USER_NAME == connUser.NAME && fil.EVENT_TIME > filDate)

                        .OrderByDescending(order => order.EVENT_TIME)

                        .FirstOrDefault();

                    if (currentLog != null)

                    {

                        if (currentLog.STATUS == (int)MARKUS_CONNECTION_TYPE.PROCESSING)

                        {

                            return -1;

                        }

                        else

                        {

                            LICENSE_LOG log = new LICENSE_LOG()

                            {

                                USER_ID = connUser.ID,

                                USER_NAME = connUser.NAME,

                                CONNECTION_ID = connectionID,

                                EVENT_TIME = DateTime.Now,

                                STATUS = (connUser.ISLICENSE == (int)LICENSE_TYPE.INACTIVE) ? (int)MARKUS_CONNECTION_TYPE.REJECT : (int)MARKUS_CONNECTION_TYPE.PROCESSING, // ** 2 인 경우는 "거부" 로 표시 

                                DESCRIPTION = (connUser.ISLICENSE == (int)LICENSE_TYPE.ACTIVE) ? null : _COMMENT.reject // ** 

                            };

                            ent.LICENSE_LOG.AddObject(log);

                            ent.SaveChanges();

                            return log.STATUS;

                        }

                    }

                    else

                    {

                        LICENSE_LOG log = new LICENSE_LOG()

                        {

                            USER_ID = connUser.ID,

                            USER_NAME = connUser.NAME,

                            CONNECTION_ID = connectionID,

                            EVENT_TIME = DateTime.Now,

                            STATUS = (connUser.ISLICENSE == (int)LICENSE_TYPE.INACTIVE) ? (int)MARKUS_CONNECTION_TYPE.REJECT : (int)MARKUS_CONNECTION_TYPE.PROCESSING, // ** 2 인 경우는 "거부" 로 표시 

                            DESCRIPTION = (connUser.ISLICENSE == (int)LICENSE_TYPE.ACTIVE) ? null : _COMMENT.reject // ** 

                        };

                        ent.LICENSE_LOG.AddObject(log);

                        ent.SaveChanges();

                        return log.STATUS;

                    }

                }

            }

            catch (Exception)

            {

                return 500;

            }

            #endregion

        }

        /// <summary>

        /// Disconnection Stamp

        /// </summary>

        /// <param name="connectionID"></param>

        /// <returns></returns>

        public bool DisConnectionStamp(string connectionID)

        {

            #region DisConnection Stamp Method 

            try

            {

                using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusConnectionString().ToString()))

                {

                    LICENSE_LOG disconnectionUSER = ent.LICENSE_LOG

                        .Where(log => log.CONNECTION_ID == connectionID)

                        .OrderByDescending(order => order.EVENT_TIME)

                        .FirstOrDefault();

                    if (disconnectionUSER != null)

                    {

                        if (disconnectionUSER.STATUS == (int)MARKUS_CONNECTION_TYPE.PROCESSING || disconnectionUSER.STATUS == (int)MARKUS_CONNECTION_TYPE.REJECT)

                        {

                            LICENSE_LOG disConnUser = new LICENSE_LOG()

                            {

                                USER_ID = disconnectionUSER.USER_ID,

                                USER_NAME = disconnectionUSER.USER_NAME,

                                CONNECTION_ID = disconnectionUSER.CONNECTION_ID,

                                EVENT_TIME = DateTime.Now,

                                STATUS = (int)MARKUS_CONNECTION_TYPE.TERMINATE

                            };

                            ent.LICENSE_LOG.AddObject(disConnUser);

                        }

                    }

                    else

                    {

                        LICENSE_LOG unknownUser = new LICENSE_LOG()

                        {

                            USER_NAME = "Unknown user",

                            USER_ID = "Unknown id",

                            CONNECTION_ID = connectionID,

                            EVENT_TIME = DateTime.Now,

                            STATUS = (int)MARKUS_CONNECTION_TYPE.TERMINATE

                        };

                        ent.LICENSE_LOG.AddObject(unknownUser);

                    }

                    ent.SaveChanges();

                    return true;

                }

            }

            catch (Exception ex)

            {

                return false;

                throw;

            }

            #endregion

        }

        /// <summary>

        /// 예기치 못하게 종료되었을 경우를 대비해 다시 한번 확인하여 로그 기록 

        /// </summary>

        /// <param name="stopCalled"></param>

        /// <returns></returns>

        public override Task OnDisconnected(bool stopCalled)

        {

            #region 종료 기록 ( 강제종료 , 시스템 종료 등 예기치 못한 상태를 대비 ) 

            try

            {

                if (stopCalled)

                {

                    Console.WriteLine(String.Format("Client {0} explicitly closed the connection.", Context.ConnectionId));

                }

                else

                {

                    Console.WriteLine(String.Format("Client {0} timed out .", Context.ConnectionId));

                }

                DisConnectionStamp(Context.ConnectionId);

                return base.OnDisconnected(stopCalled);

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message);

                throw;

            }

            #endregion

        }

        public override Task OnConnected()

        {

            // Add your own code here.

            // For example: in a chat application, record the association between

            // the current connection ID and user name, and mark the user as online.

            // After the code in this method completes, the client is informed that

            // the connection is established; for example, in a JavaScript client,

            // the start().done callback is executed.

            //Console.WriteLine("Context.ConnectionId " + Context.ConnectionId);

            //Console.WriteLine(Context.QueryString["userID"]);

            return base.OnConnected();

        }

        public override Task OnReconnected()

        {

            // Add your own code here.

            // For example: in a chat application, you might have marked the

            // user as offline after a period of inactivity; in that case 

            // mark the user as online again.

            return base.OnReconnected();

        }

        #endregion

    }

}