Kepler-Release/Venus/Framework/Common/Log/LOG.cs

using Aitex.Core.RT.SCCore;
using System;
using System.Linq;
using System.Diagnostics;
using MECF.Framework.Common.Equipment;
using System.Text;
using Aitex.Core.RT.Event;
using System.Collections.Generic;
using System.Runtime.InteropServices.ComTypes;

namespace Aitex.Core.RT.Log
{
    public static class LOG
    {
        public enum Level
        {
            Undefine,
            Debug,
            Info,
            Warning,
            Error         
        }

        public static ICommonLog InnerLogger { set;  private get; }
        public static Action<ModuleName,eEvent> PMErrorInterrupt;

        private static DateTime _lstErrTime;
        private static Queue<string> _errMessages = new Queue<string>();
        public static void onErrorInterrupt(ModuleName module,eEvent eEventid)
        {
            if (PMErrorInterrupt != null && ModuleHelper.IsPm(module))
                PMErrorInterrupt(module,eEventid);
        }

        private static void Debug(string message)
        {
            if (InnerLogger != null && SC.GetValue<bool>("System.IsOpenDebugLog") ==true)
                
                InnerLogger.Debug(message);
        }
        public static void Info(string message)
        {
            if (InnerLogger != null)
                InnerLogger.Info(message);
        }
        public static void Warning(string message)
        {
            if (InnerLogger != null)
                InnerLogger.Warning(message);
        }


        public static void Error(string message)
        {
            if (InnerLogger != null)
                InnerLogger.Error(message);
        }
        static string GetFormatStackFrameInfo(Exception ex, int traceLevel = 2)
        {
            StackFrame sf = new StackTrace(true).GetFrame(traceLevel + 1);
            string pathFile = sf.GetFileName();
            string file = string.IsNullOrEmpty(pathFile) ? "" : pathFile.Substring(pathFile.LastIndexOf('\\') + 1);
            return $"{ex.Message}\r\n{file}\tLine {sf.GetFileLineNumber()}\t{sf.GetMethod().Name}()";
        }

        public static void Write(eEvent id, string module, params string[] values)
        {
            Write(id, ModuleHelper.Converter(module), values);
        }

        public static void WriteExeption(Exception ex)
        {
            if (!_errMessages.Contains(ex.Message))
            {
                if (_errMessages.Count > 30)
                {
                    _errMessages.Dequeue();
                    _errMessages.Enqueue(ex.Message);
                }
                else
                    _errMessages.Enqueue(ex.Message);
                _lstErrTime = DateTime.Now;
                Write(eEvent.ERR_EXCEPTION, ModuleName.System, GetFormatStackFrameInfo(ex));
            }
            else if (_lstErrTime == null || (DateTime.Now - _lstErrTime).TotalMilliseconds > 10000)
            {
                _lstErrTime = DateTime.Now;
                Write(eEvent.ERR_EXCEPTION, ModuleName.System, GetFormatStackFrameInfo(ex));
            }

        }

        public static void WriteExeption(string prefix, Exception ex)
        {
            Write(eEvent.ERR_EXCEPTION, ModuleName.System, prefix + GetFormatStackFrameInfo(ex));
        }
        public static void WriteSingeLine(eEvent id, ModuleName module, string log)
        {
            string newLog = log.Replace("\r", "<回车>");
            newLog = newLog.Replace("\n", "<换行>");
            Write(id, module, newLog);
        }
        public static void Write(eEvent id, ModuleName module, params string[] values)
        {
            //U can Add here to postmsg(MSG.Error) to target entity by the func
            //if (id == eEvent.ERR_DEVICE_INFO)
            //    onErrorInterrupt(module);
            

            var logItem= LogDefineManager.LogItems?.Where(x => x.Id == id).FirstOrDefault();
            // transform the Control Char to HEX number
            if (logItem == null) 
            {
                return;
            }
            string logWithoutControlChar="";
            foreach (char logchar in string.Format(logItem.GlobalDescription_zh, values))
            {
                if (char.IsControl(logchar))
                {
                    if(logchar == 9)
                        logWithoutControlChar += logchar;
                    else
                        logWithoutControlChar += $"[{Convert.ToString(logchar,16)}]";
                }
                else if (logchar == 127)
                {
                    logWithoutControlChar += "[DEL]";
                }
                else
                {
                    logWithoutControlChar += logchar;
                }
            }


            if (logItem != null)
            {
                var item1 = logItem.Id;
                var item2 = logWithoutControlChar;
                var item3 = module.ToString();

                StringBuilder text = new StringBuilder();
                text.Append(((int)item1).ToString().PadLeft(8));
                text.Append(item3.PadLeft(12));
                text.Append("    ");
                text.Append(logWithoutControlChar);              
                string message = text.ToString();
                //test += (message + "\r\n");
                Level level = Level.Undefine;
                Enum.TryParse<Level>(logItem.Level, out level);

                switch (level)
                {
                    case Level.Debug:
                        Debug(message);
                        break;
                    case Level.Info:
                        EV.PostInfoLog(module.ToString(), id, logWithoutControlChar);
                        Info(message);
                        break;
                    case Level.Warning:
                        EV.PostWarningLog(module.ToString(),id, logWithoutControlChar);
                        Warning(message);
                        break;
                    case Level.Error:
                        EV.PostAlarmLog(module.ToString(),id, logWithoutControlChar);
                        Error(message);
                        onErrorInterrupt(module,id);
                        break;
                    default:
                        break;
                }
            }
        }           
    }
}