///<summary>
		/// Logs the message to the configured loLog4Netgger with the 
		/// appropriate <see cref="LogCategory"/>
		///</summary>
		///<param name="message"></param>
		///<param name="logCategory"></param>
		public void Log(string message, LogCategory logCategory)
		{
			if (!IsLogging(logCategory)) return;
			switch (logCategory)
			{
				case LogCategory.Fatal:
					_log.Fatal(message);
					break;
				case LogCategory.Exception:
					_log.Error(message);
					break;
				case LogCategory.Debug:
					_log.Debug(message);
					break;
				case LogCategory.Warn:
					_log.Warn(message);
					break;
                case LogCategory.Error:
                    _log.Error(message);
                    break;
				default:
					_log.Info(message);
					break;
			}
		}

 public void Log(LogCategory category, string text, params object[] parameters)
 {
     if ((EnabledCategories & category) != 0)
     {
         Stream.WriteLine(text, parameters);
     }
 }

        /// <summary>
        /// This method is used to Log any message in the Application.
        /// </summary>
        /// <param name="eventId">Id of the event. Based on which the message will be retrieved from resource file.</param>
        /// <param name="ex">Exception object that needs to be logged in.</param>
        /// <param name="message">Some extra information / message that user will like to log.</param>
        /// <param name="category">A category which will determine where the message will get logged.</param>
        /// <param name="severity">Severity of the message. (Information / Warning / Error)</param>
        public static void LogException(int eventId, Exception ex, string message, LogCategory category, TraceEventType severity)
        {
            try
            {
                var categories = new List<LogCategory> { category };

                var extendedInformation = new Dictionary<string, object> { { "Exception", ex } };

                if (string.IsNullOrEmpty(message))
                {
                    message = ex.Message + " - Stack Trace : " + ex.StackTrace;
                }
                else
                {
                    message = message + " - " + ex.Message + " - Stack Trace : " + ex.StackTrace;
                    if (message.Length > MAX_EVENTLOG_STRING_LENGTH)
                        message = message.Substring(0, MAX_EVENTLOG_STRING_LENGTH);
                }

                WriteLogEntry(eventId, message, categories, severity, extendedInformation);
            }
            catch (Exception)
            {
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogEntry"/> class by specifying the category and the detailed information to write.
 /// </summary>
 /// <param name="category">
 /// The log category of this instance.
 /// </param>
 /// <param name="data">
 /// The data containing the detailed information to write to log.
 /// </param>
 public LogEntry(LogCategory category, object data)
 {
     Id = Guid.NewGuid();
     Category = category;
     Created = DateTime.Now;
     Data = data;
 }

 public void Log(string message, LogCategory logCategory)
 {
     if (!IsLogging(logCategory)) return;
     Console.Out.WriteLine("{0} {1} {2} {3} {4}", DateTime.Now.ToShortDateString(),
                           DateTime.Now.ToShortTimeString(), _contextName,
                           Enum.GetName(typeof (LogCategory), logCategory), message);
 }

 public static void SetTraceLevel(LogCategory category, SourceLevels sourceLevel)
 {
     var sourceSwitch = new SourceSwitch(string.Format(CultureInfo.InvariantCulture, "MigSharp.{0}.Switch", category))
     {
         Level = sourceLevel
     };
     Sources[category].Switch = sourceSwitch;
 }

 /// <summary>
 /// Writes a log entry via the logger from <see cref="Logger.Current" />.
 /// </summary>
 /// <param name="msg">The message to write.</param>
 /// <param name="category">The category.</param>
 /// <param name="prio">The priority.</param>
 /// <param name="tag">The optional tag.</param>
 /// <returns>Message was written or not.</returns>
 public static bool Log(object msg,
                        LogCategory category = LogCategory.Info, LogPriority prio = LogPriority.None,
                        string tag = null)
 {
     return Current.Log(msg: msg,
                        category: category, prio: prio,
                        tag: tag);
 }

 public static void Log(this IEnumerable<Logging.ILog> logs, LogCategory category, string message)
 {
     if (null == logs)
         return;
     foreach (var l in logs)
         if(null != l)
             l.Log(category, message);
 }

 public override void Log(LogCategory category, string message)
 {
     if (this.Stack.Count == 0)
         return;
     var ts = this.Stack.Peek();
     if(null != ts)
         ts.Log(category, message);
 }

 public override void Log(LogCategory category, string message)
 {
     System.Diagnostics.Debug.WriteLine
         (
         "{0}ms\t{1}",
         this.Elapsed.TotalMilliseconds,
         message
         );
 }

        public static void LogEntryAsync(string message, LogSeverity logSeverity, LogCategory logCategory)
        {
            Task.Factory.StartNew(() => Logger.Write(new LogEntry
            {
	            Title = logCategory.ToString(),
	            Message = message,
	            Categories = new List<string> { logCategory.ToString() },
	            Severity = GetSeverity(logSeverity)
            }));
        }

        /// <summary>
        /// Async operation of <see cref="LoggerBase.Log(object, LogCategory, LogPriority, string)" /> method.
        /// </summary>
        /// <param name="msg">The message.</param>
        /// <param name="category">The category.</param>
        /// <param name="prio">The priority.</param>
        /// <param name="tag">The tag.</param>
        /// <returns>The started task.</returns>
        public Task<bool> LogAsync(object msg,
                                   LogCategory category = LogCategory.Info, LogPriority prio = LogPriority.None,
                                   string tag = null)
        {
            var logMsg = CreateMessage(msg: msg,
                                       category: category, prio: prio,
                                       tag: tag);

            return LogAsync(logMsg: logMsg);
        }

 public static void LogEntry(string message, LogSeverity logSeverity, LogCategory logCategory)
 {
     Logger.Write(new LogEntry
     {
         Title = logCategory.ToString(),
         Message = message,
         Categories = new List<string> { logCategory.ToString() },
         Severity = GetSeverity(logSeverity)
     });
 }

 public static LogMessage Create(LogCategory logCategory, LogSeverity logSeverity, string description)
 {
     return new LogMessage
         {
             Category = logCategory,
             Severity = logSeverity,
             Description = description,
             CreatedBy = "System",
             CreatedDate = DateTime.Now
         };
 }

        //[Conditional("TRACE")]
        public static void Trace(LogCategory category, string message, params object[] args)
        {
            //Queue.Queue(delegate
            //{
                ThreadContext.Properties["Category"] = category;
                string messageToLog = string.Format(message, args);

                ConsoleLog(ConsoleColor.Gray, message, args);
                _logger.Logger.Log(typeof(Log), TRACELevelTRACE, messageToLog, null);
            //});
        }

        public void Log(string msg, LogPriority priority, LogCategory category)
        {
            string padding = "------";

              Console.WriteLine(padding);

              Console.WriteLine(category.ToString());
              Console.WriteLine(priority.ToString());
              Console.WriteLine(msg);

              Console.WriteLine(padding);
        }

        /// <summary>
        /// Write a trace line with message and category.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="category">The category.</param>
        public static void WriteLine(string message, LogCategory category) {
#if DEBUG
            try {
                System.Diagnostics.Trace.WriteLine(message, category.GetDescription());
            } catch (StackOverflowException ex) {
                Console.WriteLine(ex);
            }
#else            
            if(category != LogCategory.Debug)
                System.Diagnostics.Trace.WriteLine(message, category.GetDescription());
#endif
        }

 public List<LogCategory> GetSubCategory(int fatherid)
 {
     DataTable categorytable = dal.GetSubCategory(fatherid);
     List<LogCategory> model = new List<LogCategory>();
     foreach (DataRow item in categorytable.Rows)
     {
         LogCategory mo = new LogCategory();
         mo.CategoryID = int.Parse(item["CategoryID"].ToString());
         mo.CategoryName = item["CategoryName"].ToString();
         model.Add(mo);
     }
     return model;
 }

        public void Log(string message, LogCategory category, LogPriority priority)
        {
            Message = message;
            Category = category;
            Priority = priority;

            var trace = new StackTrace();
            StackFrame frame = trace.GetFrame(1);
            MethodBase method = frame.GetMethod();

            Logger.Log(LogLevel.Info, method.DeclaringType + ": " + message);

            _aggregator.GetEvent<LogEvent>().Publish(new NLogService { Message = Message, Category = Category, Priority = Priority });
        }

        /// <summary>Logs the specified level.</summary>
        /// <param name="level">The logging level.</param>
        /// <param name="category">The category.</param>
        /// <param name="formatMessage">The format message.</param>
        /// <param name="args">The parameters used when format message.</param>
        public static void Log(TrinityLogLevel level, LogCategory category, string formatMessage, params object[] args)
        {
            if (string.IsNullOrEmpty(prefix))
                prefix = string.Format("[Trinity {0}]", Trinity.Instance.Version);

            if (category == LogCategory.UserInformation || level >= TrinityLogLevel.Error || (Trinity.Settings != null && Trinity.Settings.Advanced.LogCategories.HasFlag(category)))
            {
                string msg = string.Format(prefix + "{0} {1}", category != LogCategory.UserInformation ? "[" + category.ToString() + "]" : string.Empty, formatMessage);

                try
                {
                if (args.Length > 0)
                    msg = string.Format(msg, args);
                }
                catch
                {
                    msg = msg + " || " + args;
                }
                var key = new Tuple<LogCategory, TrinityLogLevel>(category, level);

                if (!LastLogMessages.ContainsKey(key))
                    LastLogMessages.Add(key, "");

                var allowDuplicates = Trinity.Settings != null && Trinity.Settings.Advanced != null && Trinity.Settings.Advanced.AllowDuplicateMessages;

                string lastMessage;
                if (LastLogMessages.TryGetValue(key, out lastMessage) && (allowDuplicates || lastMessage != msg))
                {
                    LastLogMessages[key] = msg;

                    switch (level)
                    {
                        case TrinityLogLevel.Error:
                            _Logger.Error(msg);
                            break;
                        case TrinityLogLevel.Info:
                            _Logger.Info(msg);
                            break;
                        case TrinityLogLevel.Verbose:
                            _Logger.Debug(msg);
                            break;
                        case TrinityLogLevel.Debug:
                            LogToTrinityDebug(msg);
                            break;
                    }
                }
            }
        }