/// <summary>
/// Log message to <see cref="ILogWriter"/>
/// </summary>
/// <param name="requestContext">Request context.</param>
/// <param name="logFlag">Log flag.</param>
/// <param name="message">Log message.</param>
/// <returns></returns>
private async Task Log(HttpRequestContext requestContext, LogFlag logFlag, StringBuilder message)
{
message.AppendLine("");
await requestContext.LogWriter.Log(
logFlag.ToString(),
message.ToString());
}
public static void Trace(string s, LogFlag flag = LogFlag.Information)
{
switch (flag)
{
case LogFlag.Debug:
if (logger.IsEnabled(LogEventLevel.Debug))
{
logger.Debug(s);
}
break;
case LogFlag.Information:
if (logger.IsEnabled(LogEventLevel.Information))
{
logger.Information(s);
}
break;
case LogFlag.Error:
if (logger.IsEnabled(LogEventLevel.Information))
{
logger.Error(s);
}
break;
default:
if (logger.IsEnabled(LogEventLevel.Information))
{
logger.Error("Bad flag in Trace function");
}
break;
}
System.Diagnostics.Debug.WriteLine(s);
}
/// <summary>
/// Error log
/// </summary>
/// <param name="obj">Object to print</param>
/// <param name="color">Font color</param>
/// <param name="flag">Flag of the log</param>
public static void LogError(System.Object obj, Color color, LogFlag flag)
{
if (obj != null && enabled && enableError && HasFlag(flag))
{
UnityEngine.Debug.LogError("<color=#" + color.ToHex() + ">" + obj.ToString() + "</color>");
}
}
public void Add(Hashtable loginInfo, LogFlag flag_lx, IList <string> messageList)
{
if (messageList != null && messageList.Count > 0)
{
foreach (string message in messageList)
{
Add(loginInfo, flag_lx, message);
}
}
}
/// <summary>
/// Logs debug statements
/// </summary>
/// <param name="message">message to log</param>
/// <param name="debugFlag">message type</param>
/// <param name="callerFilePath">caller class name</param>
/// <param name="callerName">caller method name</param>
public void LogDebug(string message, LogFlag debugFlag, [CallerFilePath] string callerFilePath = "", [CallerMemberName] string callerName = "")
{
var logMessage = new LogMessage(message, LogLevel.Debug)
{
MethodName = callerName,
FileName = Path.GetFileName(callerFilePath),
LogFlag = debugFlag,
};
if ((this.LogSettings.LogFlags & debugFlag) != 0)
{
this.LogMessage(logMessage);
}
}
public void WriteLogFileIfRequested()
{
if (LogFlag.IsEmpty())
{
return;
}
using (var stream = new FileStream(LogFlag, FileMode.Create))
{
var writer = new StreamWriter(stream);
writer.WriteLine(_log.ToString());
writer.Flush();
}
ConsoleWriter.Write(ConsoleColor.Green, "Wrote a log file to " + LogFlag);
}
/// <summary>
/// 写数据库操作日志
/// </summary>
/// <param name="loginInfo">登录信息</param>
/// <param name="flag_lx">日志类型</param>
/// <param name="content">内容</param>
public void Add(Hashtable loginInfo, LogFlag flag_lx, string content)
{
HttpContext context = HttpContext.Current;
Ts_Log log = new Ts_Log();
log.id = Guid.NewGuid().ToString();
log.IP = context.Request.UserHostAddress;
log.id_user = string.Format("{0}", loginInfo["id_user"]);
log.flag_lx = flag_lx.ToString();
log.content = content;
log.flag_from = ((FromFlag)(loginInfo["flag_from"] ?? 0)).ToString();
log.rq = DateTime.Now;
if (loginInfo.ContainsKey("ip") && !string.IsNullOrEmpty(loginInfo["ip"].ToString()))
{
log.IP = loginInfo["ip"].ToString();
}
DAL.Add(log);
}
public static void PrintLog(string logtxt, LogFlag lt = LogFlag.log)
{
Color color = Color.Black;
switch (lt)
{
default:
{
color = Color.Black;
break;
}
case LogFlag.Error:
{
color = Color.Red;
break;
}
case LogFlag.CMD:
{
color = Color.DarkGreen;
break;
}
case LogFlag.Msg:
{
color = Color.DarkBlue;
break;
}
case LogFlag.log:
{
color = Color.Black;
break;
}
}
MWRef.LogBox.AppendText(logtxt, color);
MWRef.LogBox.AppendText("\n");
}
public ILogger Log(LogFlag level, string msg, Exception t)
{
if (IsEnabled(level))
{
switch (level)
{
case LogFlag.Critical:
case LogFlag.Error:
{
EventLog.WriteEntry(this.Name, string.Format("{0} {1} {2}", msg, Environment.NewLine, t.ToString()), EventLogEntryType.Error);
break;
}
case LogFlag.Warning:
{
EventLog.WriteEntry(this.Name, string.Format("{0} {1} {2}", msg, Environment.NewLine, t.ToString()), EventLogEntryType.Warning);
break;
}
case LogFlag.Information:
{
EventLog.WriteEntry(this.Name, string.Format("{0} {1} {2}", msg, Environment.NewLine, t.ToString()), EventLogEntryType.Information);
break;
}
case LogFlag.Debug:
{
EventLog.WriteEntry(this.Name, string.Format("{0} {1} {2}", msg, Environment.NewLine, t.ToString()), EventLogEntryType.FailureAudit);
break;
}
case LogFlag.Trace:
{
EventLog.WriteEntry(this.Name, string.Format("{0} {1} {2}", msg, Environment.NewLine, t.ToString()), EventLogEntryType.SuccessAudit);
break;
}
default:
break;
}
}
return this;
}
public ILogger Log(LogFlag level, string msg)
{
if (IsEnabled(level))
{
switch (level)
{
case LogFlag.Critical:
case LogFlag.Error:
{
EventLog.WriteEntry(this.Name, msg, EventLogEntryType.Error);
break;
}
case LogFlag.Warning:
{
EventLog.WriteEntry(this.Name, msg, EventLogEntryType.Warning);
break;
}
case LogFlag.Information:
{
EventLog.WriteEntry(this.Name, msg, EventLogEntryType.Information);
break;
}
case LogFlag.Debug:
{
EventLog.WriteEntry(this.Name, msg, EventLogEntryType.FailureAudit);
break;
}
case LogFlag.Trace:
{
EventLog.WriteEntry(this.Name, msg, EventLogEntryType.SuccessAudit);
break;
}
default:
break;
}
}
return this;
}
public static void LogError <T, U>(string arrayName, T[] array, System.Func <T, U> func, LogFlag flag)
{
LogError(arrayName + " :\n" + array.ToSmartString(func, "\n"), flag);
}
public ILogger Log(LogFlag level, string format, params object[] arguments) { return this.Log(level, string.Format(format, arguments)); }
public ILogger Log(LogFlag level, string format, object argA, object argB) { return this.Log(level, string.Format(format, argA, argB)); }
public static void LogError <K, V>(string dictionaryName, Dictionary <K, V> dico, System.Func <K, string> funcKey, System.Func <V, string> funcValue, LogFlag flag)
{
LogError(dictionaryName + " :\n" + dico.ToSmartString(funcKey, funcValue, "\n"), flag);
}
public static void LogError <T>(string arrayName, T[] array, LogFlag flag)
{
LogError(arrayName, array, x => x, flag);
}
public static void LogWarning <T>(string arrayName, T[] array, LogFlag flag)
{
LogWarning(arrayName, array, x => x, flag);
}
public static void LogWarning <T>(string listName, List <T> list, LogFlag flag)
{
LogWarning(listName, list, x => x, flag);
}
void Terminate_Internal(bool success, string message, LogFlag requiredLogFlagToLog)
{
if (!IsRunning)
{
Debug.LogError("Trying to terminate an already terminated operation");
return;
}
IsRunning = false;
HasSucceeded = success;
Message = message;
// terminate ongoing sub operations
if (_ongoingSubOperations != null)
{
for (int i = 0; i < _ongoingSubOperations.Count; i++)
{
if (_ongoingSubOperations[i].IsRunning)
{
_ongoingSubOperations[i].Terminate_Internal(success, null, requiredLogFlagToLog);
}
}
_ongoingSubOperations.Clear();
}
if (success)
{
OnSucceed();
OnSucceedCallback?.InvokeCatchException(this);
}
else
{
OnFail();
OnFailCallback?.InvokeCatchException(this);
}
if (!string.IsNullOrEmpty(message) && (LogFlags & requiredLogFlagToLog) != LogFlag.None)
{
switch (requiredLogFlagToLog)
{
case LogFlag.Success:
Log.Info(message);
break;
case LogFlag.NormalFailure:
Log.Info(message);
break;
default:
case LogFlag.AbnormalFailure:
Log.Error(message);
break;
}
}
// tell unity to stop maintaning and running the coroutine
if (_coroutine != null)
{
CoroutineLauncherService.Instance?.StopCoroutine(_coroutine);
_coroutine = null;
}
for (int i = 0; i < _disposeOnTerminate.Count; i++)
{
_disposeOnTerminate[i].Dispose();
}
OnTerminate();
OnTerminateCallback?.InvokeCatchException(this);
}
public static void LogError <T>(string listName, List <T> list, LogFlag flag)
{
LogError(listName, list, x => x, flag);
}
public static void LogError <T, U>(string listName, List <T> list, System.Func <T, U> func, LogFlag flag)
{
LogError(listName + " :\n" + (list == null ? "NULL" : list.ToSmartString(func, "\n")), flag);
}
public static void LogWarning(System.Object obj, LogFlag flag)
{
Log(obj, Color.black, flag);
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="flag_lx">日志类型</param>
/// <param name="content">内容</param>
protected void WriteDBLog(LogFlag flag_lx, string content)
{
Hashtable loginInfo = (Hashtable)(Session["MobileLoginInfo"] ?? new Hashtable());
BusinessFactory.Log.Add(loginInfo, flag_lx, content);
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="flag_lx">日志类型</param>
/// <param name="messageList">消息</param>
protected void WriteDBLog(LogFlag flag_lx, IList <string> messageList)
{
Hashtable loginInfo = (Hashtable)(Session["MobileLoginInfo"] ?? new Hashtable());
BusinessFactory.Log.Add(loginInfo, flag_lx, messageList);
}
public ILogger Log(LogFlag level, Exception t) { return this.Log(level, string.Empty, t); }
public bool IsEnabled(LogFlag level) { return (byte)level > 0 && (byte)level < 7 ? this.enabledFlags[level] : false; }
public static void LogError <K, V>(string dictionaryName, Dictionary <K, V> dico, LogFlag flag)
{
LogError(dictionaryName + " :\n" + dico.ToSmartString("\n"), flag);
}
protected void WriteDBLog(LogFlag flag_lx, IList <string> messageList)
{
Hashtable loginInfo = new Hashtable();
BusinessFactory.Log.Add(loginInfo, flag_lx, messageList);
}
public static bool HasFlag(LogFlag flag)
{
//UnityEngine.Debug.Log("HasFlag("+flag+") => " + ((currentMask & (int)flag) == (int)flag));
return((currentMask & (int)flag) == (int)flag);
}
