private void logOne(string text, LogMessageTypes type)
{
if (messageEntities.Count == limit)
{
// TODO: for scrollable log history, this part will need to change
messageEntities[limit - 1].Delete();
messageEntities.RemoveAt(limit - 1);
}
var textRenderer = new TextRenderer()
{
Text = text, Font = font, Color = typeColors[type], Justification = Justifications.TopLeft
};
var textObj = new GameObject("logMsg")
{
LocalPosition = bottomMessagePosition, LayerSortingVarianceEnabled = false, Layer = 1f
};
textObj.AddComponent(textRenderer);
console.AddObj(textObj);
messageEntities.Insert(0, textObj);
for (int index = 1; index < messageEntities.Count; index++)
{
var line = messageEntities[index];
var previousLine = messageEntities[index - 1];
line.LocalPosition = line.LocalPosition.WithY(previousLine.LocalPosition.Y - lineSpacing);
}
}
public static void Write(int?chunkId, LogMessageTypes type, string message)
{
var buildingFolder = "Building";
string chunkFolder = null;
if (!string.IsNullOrEmpty(Settings.Current.Building.Folder))
{
buildingFolder = Settings.Current.Building.Folder;
}
if (chunkId.HasValue)
{
chunkFolder = Path.Combine(buildingFolder, chunkId.Value.ToString());
}
if (!Directory.Exists(buildingFolder))
{
Directory.CreateDirectory(buildingFolder);
}
if (chunkFolder != null && !Directory.Exists(chunkFolder))
{
Directory.CreateDirectory(chunkFolder);
}
if (chunkFolder != null)
{
File.AppendAllText($@"{chunkFolder}\log.txt", $@"{DateTime.Now:G}| {message}{Environment.NewLine}");
}
lock (_threadlock)
{
File.AppendAllText($@"{buildingFolder}\log.txt", $@"{DateTime.Now:G}| {message}{Environment.NewLine}");
}
}
/// <summary>
/// This method will create automaticly.
/// Log file in folder with staic path.
/// Every new day will be create a one new file.
/// </summary>
/// <param name="LogSource">Who send this message log.</param>
/// <param name="MessageText">Concreet message.</param>
public void CreateRecord(string LogSource, string MessageText, LogMessageTypes MessageType, bool EndOfLogs = false)
{
// Write LOG record to the message buffer if is enabled.
if (Enable)
{
// Structre of the message.
// LogSource\tYear.Month.Day/Hour:Minute:Seconds.Miliseconds\tType\tMessageText
string dateAndTime = DateTime.Now.ToString("yyyy.MM.dd/HH:mm:ss.fff", System.Globalization.DateTimeFormatInfo.InvariantInfo);
string message = LogSource + "\t" + dateAndTime + "\t" + MessageType.ToString() + "\t" + MessageText;
// Add message to the message buffer.
this.logMessages.Add(message);
// Write end of log line
if(EndOfLogs)
{
this.logMessages.Add("\r\n===================================================================================\r\n");
}
// If filr are critical count, just write it to a file.
if ((this.logMessages.Count > this.colectionSize) || EndOfLogs)
{
this.WtriteToLogFile();
}
}
}
public void Add(int?builderId, int?buildingId, int?chunkId, LogMessageTypes type, string message)
{
const string query =
"INSERT INTO [Log] ([ChunkId],[BuilderId],[BuildingId],[Type],[Time],[Message]) VALUES (@chunkId, @builderId, @buildingId, @type, @time, @message)";
using (var connection = SqlConnectionHelper.OpenMssqlConnection(_connectionString))
using (var cmd = new SqlCommand(query, connection)
{
CommandTimeout = 0
})
{
cmd.Parameters.Add("@chunkId", SqlDbType.Int);
cmd.Parameters["@chunkId"].Value = chunkId.HasValue ? chunkId : (object)DBNull.Value;
cmd.Parameters.Add("@builderId", SqlDbType.Int);
cmd.Parameters["@builderId"].Value = builderId.HasValue ? builderId : (object)DBNull.Value;
cmd.Parameters.Add("@buildingId", SqlDbType.Int);
cmd.Parameters["@buildingId"].Value = buildingId.HasValue ? buildingId : (object)DBNull.Value;
cmd.Parameters.Add("@type", SqlDbType.VarChar);
cmd.Parameters["@type"].Value = type.ToString();
cmd.Parameters.Add("@time", SqlDbType.DateTime);
cmd.Parameters["@time"].Value = DateTime.Now;
cmd.Parameters.Add("@message", SqlDbType.VarChar);
cmd.Parameters["@message"].Value = message;
cmd.ExecuteNonQuery();
}
}
public void LogMessage(string message, LogMessageTypes logMessageType)
{
var messageType = string.Empty;
switch(logMessageType)
{
case LogMessageTypes.Error:
messageType = "Error";
break;
case LogMessageTypes.Info:
messageType = "Info";
break;
}
using (var context = DataAccess.GetDataContext())
{
var log = new Tbl_ApplicationLog
{
LogMessage = message,
LogMessageType = messageType,
LoggedDateTime = System.DateTime.Now
};
context.Tbl_ApplicationLogs.InsertOnSubmit(log);
context.SubmitChanges();
}
}
/// <summary>
/// As this will be called many times, lets keep it short, N stands for Notify
/// </summary>
/// <param name="message"></param>
/// <param name="logMessageType"></param>
protected void N(string message, LogMessageTypes messageType = LogMessageTypes.Info)
{
if (Callback != null)
{
Callback(message, messageType);
}
}
/// <summary>
/// This method will create automaticly.
/// Log file in folder with staic path.
/// Every new day will be create a one new file.
/// </summary>
/// <param name="LogSource">Who send this message log.</param>
/// <param name="MessageText">Concreet message.</param>
public static void CreateRecord(string LogSource, string MessageText, LogMessageTypes MessageType, bool EndOfLogs = false)
{
// Write LOG record to the message buffer if is enabled.
if (Enable)
{
// Structre of the message.
// LogSource\tYear.Month.Day/Hour:Minute:Seconds.Miliseconds\tType\tMessageText
string dateAndTime = DateTime.Now.ToString("yyyy.MM.dd/HH:mm:ss.fff", System.Globalization.DateTimeFormatInfo.InvariantInfo);
string message = LogSource + "\t" + dateAndTime + "\t" + MessageType.ToString() + "\t" + MessageText;
// Add message to the message buffer.
Messages.Add(message);
// Write end of log line
if (EndOfLogs)
{
Messages.Add("\r\n===================================================================================\r\n");
}
// If filr are critical count, just write it to a file.
if ((Messages.Count > MessageColectionSize) || EndOfLogs)
{
Log.WtriteToLogFile();
}
/*
* if ((MessageType == LogMessageTypes.ERROR) && EnableBeep)
* {
* Console.Beep(5000, 20);
* }
*/
}
}
public void Add(int? builderId, int? buildingId, int? chunkId, LogMessageTypes type, string message)
{
const string query =
"INSERT INTO [Log] ([ChunkId],[BuilderId],[BuildingId],[Type],[Time],[Message]) VALUES (@chunkId, @builderId, @buildingId, @type, @time, @message)";
using (var connection = SqlConnectionHelper.OpenConnection(connectionString))
using (var cmd = new SqlCommand(query, connection) { CommandTimeout = 0 })
{
cmd.Parameters.Add("@chunkId", SqlDbType.Int);
cmd.Parameters["@chunkId"].Value = chunkId.HasValue ? chunkId : (object)DBNull.Value;
cmd.Parameters.Add("@builderId", SqlDbType.Int);
cmd.Parameters["@builderId"].Value = builderId.HasValue ? builderId : (object)DBNull.Value;
cmd.Parameters.Add("@buildingId", SqlDbType.Int);
cmd.Parameters["@buildingId"].Value = buildingId.HasValue ? buildingId : (object)DBNull.Value;
cmd.Parameters.Add("@type", SqlDbType.VarChar);
cmd.Parameters["@type"].Value = type.ToString();
cmd.Parameters.Add("@time", SqlDbType.DateTime);
cmd.Parameters["@time"].Value = DateTime.Now;
cmd.Parameters.Add("@message", SqlDbType.VarChar);
cmd.Parameters["@message"].Value = message;
cmd.ExecuteNonQuery();
}
}
public void Log(string text, LogMessageTypes messageType)
{
var fileName = GetFileName();
lock (SyncObject)
{
File.AppendAllText(fileName, GetLogEntry(text, messageType));
}
}
/// <summary>
/// As this will be called many times, lets keep it short, NL stands for Notify with new line
/// </summary>
/// <param name="message"></param>
/// <param name="logMessageType"></param>
protected void NL(string message, LogMessageTypes messageType = LogMessageTypes.Info)
{
message += Environment.NewLine;
if (Callback != null)
{
Callback(message, messageType);
}
}
public static void Log(LogMessageTypes type, string msg, string targetSite, string trace)
{
if (string.IsNullOrEmpty(LogFilePath))
{
return;
}
var dateAndTime = DateTime.Now.ToString(CultureInfo.InvariantCulture);
XDocument xdoc;
//Replace this portion with a command in options view for example to clear the log file if is exceeds a certin size.
//if (File.Exists(LogFilePath))
//{
// var info = new FileInfo(LogFilePath);
// var length = info.Length;
// if (length >= MaxFileSize)
// {
// info.Delete();
// Log(type, msg, targetSite, trace);
// }
//}
if (File.Exists(LogFilePath))
{
xdoc = XDocument.Load(LogFilePath);
var xElement = xdoc.Element("Logs");
if (xElement != null)
{
xElement.Add(
new XElement("Log",
new XElement("DateAndTime", dateAndTime),
new XElement("Type", type.ToString()),
new XElement("Message", msg),
new XElement("TargetSite", targetSite),
new XElement("Tarce", trace)
));
}
}
else
{
xdoc = new XDocument(
new XElement("Logs",
new XElement("Log",
new XElement("DateAndTime", dateAndTime),
new XElement("Type", type.ToString()),
new XElement("Message", msg),
new XElement("TargetSite", targetSite),
new XElement("Tarce", trace)
)));
}
xdoc.Save(LogFilePath);
}
public void WriteToSystemLog(int clientId, Guid messageGuid, LogMessageTypes messageType, string message)
{
string sql = "INSERT SystemLog (ClientID, LogMessageGUID, LogMessageDateTime, LogMessageType, LogMessageText) VALUES (:ClientID, :LogMessageGUID, GETDATE(), :LogMessageType, :LogMessageText)";
Session.CreateSQLQuery(sql)
.SetParameter("ClientID", clientId > 0, clientId)
.SetParameter("LogMessageGUID", messageGuid)
.SetParameter("LogMessageType", LogMessageTypeToString(messageType))
.SetParameter("LogMessageText", message)
.ExecuteUpdate();
}
public static string GetLogTypeDescription(LogMessageTypes logMessageType)
{
switch (logMessageType)
{
case LogMessageTypes.Information:
return "Сообщение";
case LogMessageTypes.Exception:
return "Исключение";
case LogMessageTypes.Warning:
return "Предупреждение";
}
return null;
}
private string LogMessageTypeToString(LogMessageTypes MessageType)
{
switch (MessageType)
{
case LogMessageTypes.Error:
return("error");
case LogMessageTypes.Warning:
return("warning");
case LogMessageTypes.Info:
return("info");
default:
return("undefined");
}
}
private void Rbac_Callback(string message, LogMessageTypes messageType)
{
switch (messageType)
{
case LogMessageTypes.Info:
Console.Write(message);
break;
case LogMessageTypes.Success:
WriteColor(ConsoleColor.Green, message + Environment.NewLine);
break;
case LogMessageTypes.Fail:
WriteErrorLine(message);
break;
}
}
public static void Log(LogMessageTypes type, string msg, string targetSite, string trace)
{
string dateAndTime = DateTime.Now.ToString();
XDocument xdoc = null;
if (File.Exists(_filePath))
{
FileInfo info = new FileInfo(_filePath);
var length = info.Length;
if (length >= MaxFileSize)
{
info.Delete();
Log(type, msg, targetSite, trace);
}
}
if (File.Exists(_filePath))
{
xdoc = XDocument.Load(_filePath);
xdoc.Element("Logs").Add(
new XElement("Log",
new XElement("DateAndTime", dateAndTime),
new XElement("Type", type.ToString()),
new XElement("Message", msg),
new XElement("TargetSite", targetSite),
new XElement("Tarce", trace)
));
}
else
{
xdoc = new XDocument(
new XElement("Logs",
new XElement("Log",
new XElement("DateAndTime", dateAndTime),
new XElement("Type", type.ToString()),
new XElement("Message", msg),
new XElement("TargetSite", targetSite),
new XElement("Tarce", trace)
)));
}
xdoc.Save(_filePath);
}
public void AddToLog(string content, LogMessageTypes msgType, bool withTimeStamp)
{
if (logText == null)
{
return;
}
entryCount++;
if (entryCount > 1)
{
logText.text += Environment.NewLine;
}
string msg = string.Empty;
if (withTimeStamp)
{
string time = DateTime.Now.ToString();
msg = time + " ";
}
switch (msgType)
{
case LogMessageTypes.Message:
msg += "[MSG " + (++msgCount).ToString() + "] " + content;
break;
case LogMessageTypes.Warning:
msg += "[WRN " + (++wrnCount).ToString() + "] " + content;
break;
case LogMessageTypes.Error:
msg += "[ERR " + (++errCount).ToString() + "] " + content;
break;
}
logText.text += msg;
}
public void Write(LogMessageTypes type, string str)
{
DebugConsole.Instance.Write(type, str); // also forward the log request to debug-console.
if (!this._loggerEnabled) return;
this._logStream.WriteLine(string.Format("[{0}][{1}]: {2}", DateTime.Now.ToString("HH:mm:ss"), type.ToString().PadLeft(5), str));
this._logStream.AutoFlush = true;
}
public static void Write(int?chunkId, LogMessageTypes type, string message)
{
Write(Settings.Settings.Current.Builder.Id, Settings.Settings.Current.Building.Id, chunkId, type, message);
}
public void LogMessage(string message, LogMessageTypes logMessageType)
{
lDal.LogMessage(message, logMessageType);
}
/// <summary>
/// 构造函数
/// </summary>
public LogMessage(string text, LogMessageTypes type)
: this(text, type, DateTime.Now)
{
}
/// <summary>
/// Writes the log message to register Log4Net appenders in config file.
/// </summary>
/// <param name="fault">The fault.</param>
/// <param name="logType">Type of the log.</param>
/// <returns></returns>
private Guid WriteLog(CustomFault fault, LogMessageTypes logType)
{
//Hp --> Logic: Break if we are debugging the code
if ((Debugger.IsAttached) &&
((logType == LogMessageTypes.Error) || (logType == LogMessageTypes.Fatal)))
{
Debugger.Break();
}
var isSuccess = false;
var ticketId = Guid.Empty;
if (fault == null)
{
return(ticketId);
}
try
{
fault.LogType = logType;
switch (fault.LogType)
{
case LogMessageTypes.None:
break;
case LogMessageTypes.Debug:
{
if (log4NetBuilder.IsDebugEnabled)
{
log4NetBuilder.Debug(fault);
isSuccess = true;
}
}
break;
case LogMessageTypes.Error:
{
if (log4NetBuilder.IsErrorEnabled)
{
log4NetBuilder.Error(fault);
isSuccess = true;
}
}
break;
case LogMessageTypes.Fatal:
{
if (log4NetBuilder.IsFatalEnabled)
{
log4NetBuilder.Fatal(fault);
isSuccess = true;
}
}
break;
case LogMessageTypes.Warning:
{
if (log4NetBuilder.IsWarnEnabled)
{
log4NetBuilder.Warn(fault);
isSuccess = true;
}
}
break;
case LogMessageTypes.Information:
{
if (log4NetBuilder.IsInfoEnabled)
{
log4NetBuilder.Info(fault);
isSuccess = true;
}
}
break;
default:
{
isSuccess = false;
}
break;
}
}
catch
{
isSuccess = false;
}
finally
{
if (!isSuccess)
{
//Hp --> Logic: If log4Net fails to write then return empty ticket id.
fault.TicketNumber = Guid.Empty;
}
ticketId = fault.TicketNumber;
if (fault.IsNotifyUser)
{
//Hp --> Logic: Shows generic error message to user.
throw new FaultException <CustomFault>(fault, fault.Reason);
}
}
return(ticketId);
}
/// <summary>
/// 构造函数
/// </summary>
public LogMessage(string text, LogMessageTypes type, DateTime dateTime)
{
this.text = text;
this.type = type;
this.dateTime = dateTime;
}
/// <summary>
/// 写日志
/// </summary>
public void Write(string message, LogMessageTypes type)
{
Write(new LogMessage(message, type));
}
public static string GetFirstLetter(this LogMessageTypes messageType)
{
return(messageType.ToString().Substring(0, 1).ToUpper());
}
public static void Write(int?builderId, int?buildingId, int?chunkId, LogMessageTypes type, string message)
{
DbLog.Add(builderId, buildingId, chunkId, type, message);
}
public static void Write(int? builderId, int? buildingId, int? chunkId, LogMessageTypes type, string message)
{
DbLog.Add(builderId, buildingId, chunkId, type, message);
}
public static void Write(int? chunkId, LogMessageTypes type, string message)
{
Write(Settings.Current.Builder.Id, Settings.Current.Building.Id, chunkId, type, message);
}
public void Log(string text, LogMessageTypes messageType)
{
}
public void LogFormat(LogMessageTypes messageType, string text, params object[] values)
{
}
public void LogFormat(LogMessageTypes messageType, string text, params object[] values)
{
throw new NotImplementedException();
}
public LogMessage(string text, LogMessageTypes type = LogMessageTypes.Info)
{
Text = text;
Type = type;
}
private string GetLogEntry(string text, LogMessageTypes messageType)
{
return($"{DateTime.Now.ToString("HH:mm:ss")}: {messageType.GetFirstLetter()}: {text}\r\n");
}
public void WriteToSystemLog(int clientId, Guid messageGuid, LogMessageTypes messageType, string message)
{
throw new NotImplementedException();
}
public static void WriteToSystemLog(int clientId, Guid messageGuid, LogMessageTypes messageType, string message)
{
ServiceProvider.Current.Log.WriteToSystemLog(clientId, messageGuid, messageType, message);
}
public static void Log(LogMessageTypes type, string msg)
{
Log(type, msg, "NoNeed", "NoNeed");
}
