public void generateLog()
{
Random rnd = new Random();
int[] appIDs = { 1, 2, 3, 1003, 1005 };
for (int i = 0; i < 5; i++)
{
Application app = new Application()
{
appId = appIDs[rnd.Next(5)] //1005 //rnd.Next(1, 4)
};
logType lt = new logType()
{
typeID = rnd.Next(1, 6)
};
ErrorLog newLog = new ErrorLog();
newLog.fileName = "logfile_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".txt";
newLog.Application = app;
newLog.logType = lt;
string result = RestInteraction.RestInteraction.AddErrorLog(newLog);
Console.WriteLine(result);
Console.WriteLine();
}
}
/// <summary>
/// create an entry into the log with a string as a sender
/// </summary>
/// <param name="Msg">the message</param>
/// <param name="type">the type of the entry</param>
/// <param name="sender">the sender as a string</param>
/// <returns>the message in the log format</returns>
public static string logInput(string Msg, logType type, string sender)
{
if (sender != null)
{
logFormat = DateTime.Now.ToShortDateString().ToString() + " " + DateTime.Now.ToLongTimeString().ToString() +
" [" + type.ToString() + "] " +
" | " + sender + " ==> ";
}
else
{
logFormat = DateTime.Now.ToShortDateString().ToString() + " " + DateTime.Now.ToLongTimeString().ToString() + " ==> ";
}
sw.WriteLine(logFormat + " " + Msg);
sw.Flush();
//dispatch the message to the visual consol
if (logMessageReceivedEventHandler != null)
{
logMessageReceivedEventHandler(sender, new LogMessageEvent(logFormat + " " + Msg));
}
Console.WriteLine(logFormat + " " + Msg);
return(logFormat + " " + Msg);
}
protected override void addImpl(string message, logType t, int eventId = 0)
{
// log in the log
switch (t)
{
case logType.error:
{
EventLog.WriteEntry(source_, message, EventLogEntryType.Error, eventId);
break;
}
case logType.info:
{
EventLog.WriteEntry(source_, message, EventLogEntryType.Information, eventId);
break;
}
case logType.warning:
{
EventLog.WriteEntry(source_, message, EventLogEntryType.Warning, eventId);
break;
}
default:
{
throw new Exception("undefined message type");
}
}
}
public bool log(logType type, string val, DateTime time)
{
try
{
//Query opstellen.
var succes = 0;
_connection.Open();
_command = _connection.CreateCommand();
var query = $"insert into logs (logtype, value, time) values ('{getIdFromLogType(type)}','{val}','{time.ToString("yyyy-MM-dd HH:mm:ss")}')";
_command.CommandText = query;
//Connectie uitvoeren.
succes = _command.ExecuteNonQuery();
_connection.Close();
//Terug sturen of het is gelukt of niet.
if (succes > 0)
{
return(true);
}
return(false);
}
catch (Exception)
{
_connection.Close();
return(false);
}
}
protected override void addImpl(string message, logType t, int eventId = 0)
{
lock (m_)
{
// log in the log
switch (t)
{
case logType.error:
{
Console.WriteLine("[ERR] {0}", message);
break;
}
case logType.info:
{
Console.WriteLine("[INF] {0}", message);
break;
}
case logType.warning:
{
Console.WriteLine("[WAR] {0}", message);
break;
}
default:
{
throw new Exception("undefined message type");
}
}
}
}
/// <summary>
/// Salva la stringa che deve scrivere in una lista, pulisce il logger e mostra le stringhe delle liste
/// </summary>
/// <param name="_stringToWrite">Cosa scrivere all'interno del logger</param>
public void WriteInLogger(string _textToWrite, logType _typeOfLog)
{
switch (_typeOfLog)
{
case logType.Population:
PopulationStrings.Add(_textToWrite);
break;
case logType.Building:
BuildingStrings.Add(_textToWrite);
break;
case logType.Event:
EventStrings.Add(_textToWrite);
break;
case logType.LowPriority:
LowPriorityStrings.Add(_textToWrite);
break;
default:
break;
}
ShowInLogger();
//LoggerText.text = DateTime.Now + ": " + _textToWrite + "\n ************ \n" + LoggerText.text;
}
public static void Log(string Text, logType Type)
{
if (logActionStatus[(int)Type])
{
Engine.Program.GUI.logText(Text, Type);
}
}
public void add(string message, logType t, verbosity v, int eventId = 0)
{
if (v >= threshold_)
{
addImpl(message, t, eventId);
}
}
private static void CreateFileLog(logType typeLog, string messageErro, string filepath, string method)
{
using (StreamWriter sw = File.CreateText(filepath))
{
sw.WriteLine(string.Format("{0} [{1}]: {2} {3}", DateTime.Now, typeLog, messageErro, method));
}
}
public static void WriteLogFile(logType type, string message, string extras = "")
{
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
if (form != null)
{
if (type == logType.Debug)
{
if (bool.Parse(config.AppSettings.Settings["DebugMode"].Value.ToString()))
{
form.LogOutput.Items.Add(DateTime.Now.ToString("HH:mm:ss") + ": ----" + type.ToString() + ": " + message + " " + extras);
}
}
else
{
form.LogOutput.Items.Add(DateTime.Now.ToString("HH:mm:ss") + ": ----" + type.ToString() + ": " + message + " " + extras);
}
form.LogOutput.SelectedIndex = form.LogOutput.Items.Count - 1;
form.LogOutput.SelectedIndex = -1;
}
else
{
return;
}
}
public static void Log(string Text, logType Type)
{
if (logActionStatus[(int)Type])
{
ObjectTree.Application.GUI.logText(Text, Type);
}
}
/// <summary>
/// Event invoker za ProcessFeedback
/// </summary>
/// <remarks>
/// Aktivira se kada dodje do bilo koje promene u statusu procesa - tj kada dodje ErrorOutput ili StandardOutput
/// Ovaj method pozvati kada treba da se pokrene izvrsavanje dogadjaja
/// </remarks>
/// <example>
/// Primer poziva ka izvrsenju eventa - bez argumenata
/// <code>
/// freeRunnerModule.callProcessFeedback();
/// </code>
/// </example>
/// <example>
/// Primer poziva ka izvrsenju eventa - sa argumentom
/// <code>
/// freeRunnerModule.callProcessFeedback(this, null);
/// </code>
/// </example>
/// <param name="sender">Objekat koji je pozvao izvrsavanje</param>
/// <param name="e">Argumenti dogadjaja</param>
public void callProcessFeedback(String logMessage = "", logType msgType = logType.ExecutionError)
{
if (onProcessFeedback != null)
{
onProcessFeedback(new imbConsoleLog(logMessage, msgType));
}
}
// Log 调用 注意Warning和Error时应有第二个参数 不换行有第三参数为false
public void Log_Terminal(string log, logType logtype = logType.CommonLog, bool addNewLine = true)
{
if (addNewLine)
{
log += Environment.NewLine;
}
Color color = new Color();
switch (logtype)
{
case logType.CommonLog:
color = Color.Green;
break;
case logType.Warning:
color = Color.Orange;
break;
case logType.Error:
color = Color.Red;
break;
}
Terminal.SelectionStart = Terminal.TextLength;
Terminal.SelectionLength = 0;
Terminal.SelectionColor = color;
string text = $@"[{DateTime.Now.ToLongTimeString()}] {log}";
Terminal.Focus(); //warning:这句话没有的话会使得terminal不能跟踪到最新的log
Terminal.AppendText(text);
Terminal.SelectionColor = Terminal.ForeColor;
}
public static void custom(logType type, g group, string message, params object[] args)
{
switch (type)
{
case logType.info:
info(group, message, args);
break;
case logType.warn:
warn(group, message, args);
break;
case logType.error:
error(group, message, args);
break;
case logType.debug:
debug(group, message, args);
break;
case logType.temp:
temp(message, args);
break;
case logType.wrong:
wrong(message, args);
break;
default:
info(group, message, args);
break;
}
}
/// <summary>
/// Logs any system messages to console depending on severity
/// </summary>
public static void consoleLog(string message, logType logtype)
{
string TimeStamp = DateTime.Now.ToLongTimeString() + " [" + logtype + "]";
switch (logtype)
{
case logType.System:
Console.ForegroundColor = ConsoleColor.Green;
break;
case logType.Info:
Console.ForegroundColor = ConsoleColor.White;
break;
case logType.Debug:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case logType.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
}
Console.WriteLine(TimeStamp + ": " + message);
Console.ForegroundColor = ConsoleColor.White;
}
public static bool LogWrite(string text, logType logtype)
{
StreamWriter sw = sw_info;
switch (logtype)
{
case logType.Info:
sw = sw_info;
break;
case logType.Filliste_konvertert:
sw = sw_filliste_konvertert;
break;
case logType.Filliste_ikkekonvertert:
sw = sw_filliste_ikkekonvertert;
break;
}
if (logtype == logType.Filliste_konvertert || logtype == logType.Filliste_ikkekonvertert)
{
sw.WriteLine(text);
}
else
{
sw.WriteLine(DateTime.Now.ToShortDateString() + "-" + DateTime.Now.ToShortTimeString() + " : " + text);
}
sw.Flush();
return(true);
}
public static void log(string text, logType l)
{
using (var f = File.Open(logF, FileMode.Append)) // Open the log file
{
byte[] bytes = null;
if (l == logType.silent)
{
bytes = Encoding.ASCII.GetBytes("[SILENT]" + text + '\n');
}
else
{
bytes = Encoding.ASCII.GetBytes(text + '\n');
} // Write the log, then make a new line
f.Write(bytes, 0, bytes.Length); // Write the file.
}
if (l == logType.error)
{
Console.ForegroundColor = ConsoleColor.DarkRed; // Set the color to dark red.
Console.WriteLine("[ERROR]: " + text); // Write the text.
Console.ForegroundColor = ConsoleColor.Gray; // Reset the color.
}
else if (l == logType.regular)
{
Console.WriteLine(text); // Write the text.
}
}
protected Group(g group, string text, bool useWaitCursor, logType type)
{
this.group = group;
Text = RemoveDots(text);
UseWaitCursor = useWaitCursor;
LogType = type;
Init();
}
/// <summary>
/// Funzione per scrivere all'interno del logger
/// </summary>
/// <param name="_stringToWrite">Cosa scrivere all'interno del logger</param>
public void WriteInLogger(string _stringToWrite, logType _typeOfLog)
{
//controlla se c'è il collegamento al logger
if (logger != null)
{
logger.WriteInLogger(_stringToWrite, _typeOfLog);
}
}
public LogsMap()
{
this._id = this.id;
this._LT = this.LT;
this._timeOfEvent = this.timeOfEvent;
this._uid1 = this.uid1;
this._uid2 = this.uid2;
this._logData = this.logData;
}
public LogsMap()
{
this._id = this.id;
this._LT = this.LT;
this._timeOfEvent = this.timeOfEvent;
this._uid1 = this.uid1;
this._uid2 = this.uid2;
this._logData = this.logData;
}
/// <summary>
/// create an entry into the log with a class as a sender
/// </summary>
/// <param name="Msg">the message</param>
/// <param name="type">the type of entry</param>
/// <param name="sender">the sender as a class</param>
public static void logInput(string Msg, logType type, object sender = null)
{
if (sender != null)
{
logInput(Msg, type, sender.GetType().Name);
}
else
{
logInput(Msg, type, null);
}
}
public int getIdFromLogType(logType type)
{
//Id terug sturen waarvan de enum overeenkomt in de dictionary.
int id;
if (_dbTypeIds.TryGetValue(type, out id))
{
return(id);
}
return(-1);
}
/// <summary>
/// Create log file and start logger thread
/// </summary>
/// <param name="LogPath">Absolute path to logs directory</param>
public void Initialise(string LogPath, ConsoleColor[] backColor, ConsoleColor[] foreColor, logType LogLevel, bool debug, bool dev)
{
logPath = LogPath;
logBackColor = backColor;
logForeColor = foreColor;
logLevel = LogLevel;
_debug = debug;
_dev = dev;
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
Write("Log Directory Created", logType.info);
}
else
{
//Sort old logs
string[] files = Directory.GetFiles(logPath);
foreach (string file in files)
{
if (Path.GetExtension(file) == ".log")
{
string name = Path.GetFileName(file);
name = name.Substring(0, Math.Min(name.Length, 10));
if (name.Length == 10)
{
if (name != DateTime.UtcNow.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture))
{
int y;
int m;
int d;
if (int.TryParse(new string(name.Take(4).ToArray()), out y) && int.TryParse(new string(name.Skip(5).Take(2).ToArray()), out m) && int.TryParse(new string(name.Skip(8).Take(2).ToArray()), out d))
{
if (!Directory.Exists(logPath + "/" + y + "/" + m + "/" + d))
{
Directory.CreateDirectory(logPath + "/" + y + "/" + m + "/" + d);
}
File.Move(file, logPath + "/" + y + "/" + m + "/" + d + "/" + Path.GetFileName(file));
}
}
}
}
}
}
int i = 0;
while (File.Exists(logPath + "/" + DateTime.UtcNow.ToString("yyyy-MM-dd-", CultureInfo.InvariantCulture) + i + ".log"))
{
i++;
}
logPath = logPath + "/" + DateTime.UtcNow.ToString("yyyy-MM-dd-", CultureInfo.InvariantCulture) + i + ".log";
Write("Log path:" + logPath, logType.debug);
Updater = new Thread(new ThreadStart(UpdaterLoop));
Updater.Start();
}
public void Log(IWork work, logType type, string message)
{
lock (_logList)
{
if (_lastLog.Type != type || _lastLog.Message != message)
_logList.Add(_lastLog = new logLine(type, message));
if (!String.IsNullOrEmpty(_fileName) && (type == logType.error || type == logType.success))
using (StreamWriter sw = new StreamWriter(File.OpenWrite(_fileName)))
foreach (var line in _logList)
sw.WriteLine(String.Format("[{0}] {1} - {2}", line.Time, line.Type.ToString(), line.Message));
}
}
public static void WriteToLogFile(logType typeLog, string messageErro, string method)
{
try
{
#region Folder ops
string pathFolder = string.Format("{0}{1}", ConfigurationManager.AppSettings["PastaModels"], "\\logs");
if (!Directory.Exists(pathFolder))
{
Directory.CreateDirectory(pathFolder);
}
#endregion
string filepath = string.Format("{0}\\{1}.txt", pathFolder, "logs");
if (!File.Exists(filepath))
{
#region CreateFile
CreateFileLog(typeLog, messageErro, filepath, method);
#endregion
}
else
{
#region Size and Append
if (ConvertBytesToMegabytes(File.ReadAllBytes(filepath).Length) >= 20.0)
{
string[] txtList = Directory.GetFiles(pathFolder, "*.txt");
foreach (string f in txtList)
{
File.Delete(f);
}
CreateFileLog(typeLog, messageErro, filepath, method);
}
else
{
#region Append
using (StreamWriter sw = File.AppendText(filepath))
{
sw.WriteLine(string.Format("{0} [{1}]: {2} {3}", DateTime.Now, typeLog, messageErro, method));
}
#endregion
}
#endregion
}
}
catch (Exception ex)
{
Console.WriteLine("\nTem certeza que colocou o endereço correto para a pasta?");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// 初始化配置
/// </summary>
static myLog()
{
string log = DataAccRes.AppSettings("mylogtype");
if (string.IsNullOrEmpty(log))
return;
islog = true;
log = log.ToLower();
if ("windows" == log)
logtype = logType.Windows;
else if ("file" == log)
logtype = logType.File;
else
islog = false;
}
public static void Log(logType type, string text)
{
switch (type)
{
case logType.Info:
Console.ForegroundColor = ConsoleColor.Cyan;
break;
case logType.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case logType.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
}
Console.WriteLine("[{0}-{1}] {2}", type.ToString().ToUpper(), DateTime.Now, text);
Console.ResetColor();
}
public void Log(IWork work, logType type, string message)
{
lock (_logList)
{
if (_lastLog.Type != type || _lastLog.Message != message)
{
_logList.Add(_lastLog = new logLine(type, message));
}
if (!String.IsNullOrEmpty(_fileName) && (type == logType.error || type == logType.success))
{
using (StreamWriter sw = new StreamWriter(File.OpenWrite(_fileName)))
foreach (var line in _logList)
{
sw.WriteLine(String.Format("[{0}] {1} - {2}", line.Time, line.Type.ToString(), line.Message));
}
}
}
}
void Log(string logMessage, TextWriter txtWriter, logType logtype)
{
try
{
if (LogLevel == logType.All || LogLevel == logtype)
{
var lognameType = Enum.GetName(typeof(logType), logtype);
txtWriter.Write(string.Format("\r\n{0} Entry : ", lognameType));
txtWriter.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(),
DateTime.Now.ToLongDateString());
txtWriter.WriteLine(" {0}: ", logMessage.Replace("\n\r", Environment.NewLine));
txtWriter.WriteLine("-------------------------------");
}
}
#pragma warning disable CS0168 // The variable 'ex' is declared but never used
catch (Exception)
#pragma warning restore CS0168 // The variable 'ex' is declared but never used
{
}
}
public void LogWrite(string logMessage, logType logType = logType.information)
{
FileOutputPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var logFile = Path.Combine(FileOutputPath, ServiceConfig.FolderMonitorLogFilename);
try
{
if (!File.Exists(logFile))
{
File.CreateText(logFile).Close();
}
using (StreamWriter w = File.AppendText(logFile))
{
Log(logMessage, w, logType);
w.Close();
}
}
catch
{
}
}
/// <summary>
/// 初始化配置
/// </summary>
static myLog()
{
string log = DataAccRes.AppSettings("mylogtype");
if (string.IsNullOrEmpty(log))
{
return;
}
islog = true;
log = log.ToLower();
if ("windows" == log)
{
logtype = logType.Windows;
}
else if ("file" == log)
{
logtype = logType.File;
}
else
{
islog = false;
}
}
private void dataReceivedHandler(String message, Boolean isError)
{
freeRunnerLoging logMode = StandardMode;
logType type = logType.Notification;
if (isError)
{
logMode = ErrorMode;
type = logType.ExecutionError;
}
switch (logMode)
{
case freeRunnerLoging.collectAndSendToLogSystem:
lastResponse += message + Environment.NewLine;
logSystem.log(message, type);
break;
case freeRunnerLoging.collectToResponse:
lastResponse += message + Environment.NewLine;
break;
case freeRunnerLoging.sendToLogSystem:
lastResponse = message;
logSystem.log(message, type);
break;
case freeRunnerLoging.keepLastResponse:
lastResponse = message;
break;
default:
break;
}
callProcessFeedback(message, type);
refresh();
}
public static bool LogWrite(string text, logType logtype)
{
StreamWriter sw = sw_info;
switch (logtype)
{
case logType.Info:
sw = sw_info;
break;
case logType.Filliste_konvertert:
sw = sw_filliste_konvertert;
break;
case logType.Filliste_ikkekonvertert:
sw = sw_filliste_ikkekonvertert;
break;
}
if (logtype == logType.Filliste_konvertert || logtype == logType.Filliste_ikkekonvertert)
sw.WriteLine(text);
else
sw.WriteLine(DateTime.Now.ToShortDateString() + "-" + DateTime.Now.ToShortTimeString() + " : " + text);
sw.Flush();
return true;
}
public void Log(IWork work, logType type, string message)
{
}
public static void Log(string Text, logType Type)
{
if (logActionStatus[(int)Type])
ObjectTree.Application.GUI.logText(Text, Type);
}
/// <summary>
/// Toggles the log yes/no status of a certain log type.
/// </summary>
/// <param name="Type">The logtype to toggle the status of/.</param>
public static void toggleLogStatus(logType lType)
{
int iType = (int)lType;
logActionStatus[iType] = !logActionStatus[iType];
}
/// <summary>
/// create an entry into the log with a class as a sender
/// </summary>
/// <param name="Msg">the message</param>
/// <param name="type">the type of entry</param>
/// <param name="sender">the sender as a class</param>
public static void logInput(string Msg, logType type, object sender = null)
{
if (sender != null)
{
logInput(Msg, type, sender.GetType().Name);
}
else
{
logInput(Msg, type, null);
}
}
public logLine(logType type, string message)
{
Time = DateTime.Now;
Type = type;
Message = message;
}
/// <summary>
/// create an entry into the log with a string as a sender
/// </summary>
/// <param name="Msg">the message</param>
/// <param name="type">the type of the entry</param>
/// <param name="sender">the sender as a string</param>
/// <returns>the message in the log format</returns>
public static string logInput(string Msg, logType type, string sender)
{
if (sender != null)
{
logFormat = DateTime.Now.ToShortDateString().ToString() + " " + DateTime.Now.ToLongTimeString().ToString() +
" [" + type.ToString() + "] " +
" | " + sender + " ==> ";
}
else
{
logFormat = DateTime.Now.ToShortDateString().ToString() + " " + DateTime.Now.ToLongTimeString().ToString() + " ==> ";
}
sw.WriteLine(logFormat + " " + Msg);
sw.Flush();
//dispatch the message to the visual consol
if (logMessageReceivedEventHandler != null) logMessageReceivedEventHandler(sender , new LogMessageEvent(logFormat + " " + Msg));
Console.WriteLine(logFormat + " " + Msg);
return logFormat + " " + Msg;
}
