public NullFileLogger(string filename, bool append, string dateFormat, ESeverity filter)
{
Filename = filename;
Append = append;
DateFormat = dateFormat;
Filter = filter;
}
private static void addLineToLog(String tag, string sLine, ESeverity severity, bool bShowinStatusbar = false)
{
logList.Add(DateTime.Now.ToLongTimeString() + " - " + sLine);
if (logList.Count > MAX_LINES)
{
logList.Take();
}
if (LogAdded != null || (StatusChanged != null && bShowinStatusbar))
{
LogEventArgs args = new LogEventArgs(severity, tag, sLine, bShowinStatusbar);
if (!Application.Current.Dispatcher.CheckAccess())
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
LogAdded?.Invoke(null, args);
if (bShowinStatusbar)
{
StatusChanged?.Invoke(null, args);
}
}));
}
else
{
LogAdded?.Invoke(null, args);
if (bShowinStatusbar)
{
StatusChanged?.Invoke(null, args);
}
}
}
}
public void Log(object sender, string message, ESeverity severity)
{
if (Logger != null)
{
Logger.Log(sender, message, severity);
}
}
public static void LogMessage(string message, string source, EType type, ESeverity severity)
{
string logPath = ConfigurationManager.AppSettings["LogPath"];
string logFileName = StringFormatter.SafeFileName(String.Format("{0}.txt", DateTime.Now.ToShortDateString()));
StreamWriter writer = null;
//Open stream writer depending on if this is a new file or not
try
{
if (!File.Exists(logPath + logFileName))
{
writer = File.CreateText(logPath + logFileName);
}
else
{
writer = File.AppendText(logPath + logFileName);
}
//write log entry
string logEntry = DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt") + ControlCharacters.Tab + EnumFormatter.ToString(type) + ControlCharacters.Tab + EnumFormatter.ToString(severity) + ControlCharacters.Tab + source + ControlCharacters.Tab + StringFormatter.RemoveInvisibleCharacters(message);
writer.WriteLine(logEntry);
}
catch
{
throw;
}
finally
{
writer.Close();
}
}
public LogEventArgs(ESeverity severity, string tag, string message, bool showInStatusbar)
{
Severity = severity;
Tag = tag;
Message = message;
ShowInStatusbar = showInStatusbar;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log vierge
/// </summary>
/// -----------------------------------------------------------------------------
protected BaseLogger()
{
Filter = ESeverity.DEBUG;
DateFormat = "dd/MM/yyyy HH:mm:ss";
StringFormat = ConfigTagStart + ETags.TIMESTAMP + ConfigTagEnd + " " + ConfigTagStart + ETags.SEVERITY + ConfigTagEnd + " [" + ConfigTagStart + ETags.TYPE + ConfigTagEnd + "] " + ConfigTagStart + ETags.MESSAGE + ConfigTagEnd;
Enabled = true;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log
/// </summary>
/// <param name="writer">le textwriter pour la sortie des logs</param>
/// <param name="dateFormat">le format des dates de timestamp</param>
/// <param name="filter">le niveau de filtrage pour la sortie des logs</param>
/// -----------------------------------------------------------------------------
protected BaseLogger(TextWriter writer, string dateFormat, ESeverity filter)
{
StringFormat = ConfigTagStart + ETags.TIMESTAMP + ConfigTagEnd + " " + ConfigTagStart + ETags.SEVERITY + ConfigTagEnd + " [" + ConfigTagStart + ETags.TYPE + ConfigTagEnd + "] " + ConfigTagStart + ETags.MESSAGE + ConfigTagEnd;
Enabled = true;
Writer = writer;
DateFormat = dateFormat;
Filter = filter;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose. L'écriture sera propagée à tous les flux associés
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public override void Log(object sender, string message, ESeverity severity)
{
if (Enabled)
{
foreach (var logger in _loggers)
logger.Log(sender, message, severity);
}
}
public Error(string file, string description, int lineno, int charno, ESeverity severity)
{
File = file;
Description = description;
LineNo = lineno;
CharNo = charno;
Line = String.Empty;
}
public override void Log(object sender, string message, ESeverity severity)
{
if ((severity == ESeverity.ERROR) && (_guiclient != null) && (_guiclient.MainComponent != null) &&
(_guiclient.MainComponent.NotifyIcon != null))
{
_guiclient.MainComponent.NotifyIcon.ShowBalloonTip(_timeout, _tipTitle, message, ToolTipIcon.Error);
}
}
protected BaseLogger(TextWriter writer, string prefix, Configuration.ConfigPackage config)
{
Writer = writer;
Enabled = config.ValueBool(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigEnabled, Enabled);
Filter = (ESeverity)Enum.Parse(typeof(ESeverity), config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigFilter, Filter.ToString()));
DateFormat = config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigDateFormat, DateFormat);
StringFormat = config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigStringFormat, StringFormat);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose. L'écriture sera propagée à tous les flux associés
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public override void Log(object sender, string message, ESeverity severity)
{
if (Enabled)
{
foreach (var logger in _loggers)
{
logger.Log(sender, message, severity);
}
}
}
public virtual void Log(object sender, string message, ESeverity severity)
{
if (Logger != null)
{
Logger.Log(sender, message, severity);
}
if (GlobalLogger != null)
{
GlobalLogger.Log(sender, message, severity);
}
}
/// <summary>
/// Ritorna il numero di messaggi di una certa severità
/// </summary>
/// <param name="severity"></param>
/// <returns></returns>
public int CountForSeverity(ESeverity severity)
{
int iTemp = 0;
for (int i = 0; i < this.Count; i++)
{
if (this[i].Severity == severity)
{
iTemp++;
}
}
return(iTemp);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public virtual void Log(object sender, string message, ESeverity severity)
{
if ((Enabled) && (severity >= Filter) && (Writer != null))
{
// Remplacement des id chaines de ETags en leur équivalent integer
string format = StringFormat;
foreach (ETags tag in Enum.GetValues(typeof(ETags)))
{
format = format.Replace(tag.ToString(), Convert.ToInt32(tag).ToString(CultureInfo.InvariantCulture));
}
Writer.WriteLine(format, DateTime.Now.ToString(DateFormat), severity, sender.GetType().Name, message);
Writer.Flush();
}
}
public Message(int code, string text, ESeverity severity, string uifield, Dictionary <string, string> paramsIn)
{
this.Code = code;
this.Text = text;
this.Severity = severity;
this.UiField = uifield;
if (paramsIn != null)
{
foreach (var item in paramsIn)
{
this.Params[item.Key] = item.Value;
}
}
}
public static void Log(string message, string source, EType type, ESeverity severity, ELoggerDataAccessType dataAccessType)
{
bool debug = StringFormatter.ToBool(ConfigurationManager.AppSettings["debug"]);
if (severity != ESeverity.Debug || debug)
{
switch (dataAccessType)
{
case ELoggerDataAccessType.TextFile:
LoggerDataAccessTextFile.LogMessage(message, source, type, severity);
break;
case ELoggerDataAccessType.ApplicationEventLog:
throw new NotImplementedException();
}
}
}
public virtual void Log(object sender, string message, ESeverity severity)
{
if (!Enabled || (severity < Filter) || (Writer == null))
{
return;
}
var format = StringFormat;
foreach (ETags tag in Enum.GetValues(typeof(ETags)))
{
format = format.Replace(tag.ToString(), Convert.ToInt32(tag).ToString(CultureInfo.InvariantCulture));
}
Writer.WriteLine(format, DateTime.Now.ToString(DateFormat), severity, sender.GetType().Name, message);
Writer.Flush();
}
public void LogMessage(ESeverity severity, string sMessage)
{
switch (severity)
{
case ESeverity.eSev_Info:
LogInfo(sMessage);
break;
case ESeverity.eSev_Warning:
LogWarning(sMessage);
break;
case ESeverity.eSev_Error:
LogError(sMessage);
break;
default:
throw new Exception("Invalid value for ESeverity");
}
}
/// <summary>
/// Aggiunge messaggio di tipo impostabile
/// </summary>
/// <param name="code"></param>
/// <param name="message"></param>
/// <param name="severity"></param>
/// <param name="uifiled"></param>
public void Add(int code, string message, ESeverity severity, string uifiled)
{
this.Add(new Message(code, message, severity, uifiled));
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log à partir des données fournies dans une configuration
/// </summary>
/// <param name="writer">le textwriter pour la sortie des logs</param>
/// <param name="prefix">le prefixe dans la configuration ex: application/log</param>
/// <param name="config">la configuration pour la lecture des parametres</param>
/// -----------------------------------------------------------------------------
protected BaseLogger(TextWriter writer, string prefix, Configuration.ConfigPackage config)
{
Writer = writer;
Enabled = config.ValueBool(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigEnabled, Enabled);
Filter = ((ESeverity)Enum.Parse(typeof(ESeverity), config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigFilter, Filter.ToString())));
DateFormat = config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigDateFormat, DateFormat);
StringFormat = config.Value(prefix + Configuration.BaseConfig.SourceItemAttribute + ConfigStringFormat, StringFormat);
}
/// <summary>
/// Aggiunge messaggio con codice, sevarita' e messaggio in notazione String.Format
/// </summary>
/// <param name="code"></param>
/// <param name="severity"></param>
/// <param name="messageFmt"></param>
/// <param name="args"></param>
public void AddFormat(int code, ESeverity severity, string messageFmt, params object[] args)
{
this.Add(code, string.Format(messageFmt, args), severity, string.Empty);
}
public NullConsoleLogger(string dateFormat, ESeverity filter)
{
DateFormat = dateFormat;
Filter = filter;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log
/// </summary>
/// <param name="filename">le nom du fichier dans lequel écrire</param>
/// <param name="append">si false la fichier sera écrasé</param>
/// <param name="dateFormat">le format des dates de timestamp</param>
/// <param name="filter">le niveau de filtrage pour la sortie des logs</param>
/// -----------------------------------------------------------------------------
public NullFileLogger (string filename, bool append, string dateFormat, ESeverity filter) {
Filename = filename;
Append = append;
DateFormat = dateFormat;
Filter = filter;
}
public CommandResult(Command command, ESeverity severity)
{
Command = command;
Severity = severity;
}
private void Log(string message, ESeverity severity)
{
Log(this, message, severity);
}
public Response(ESeverity severity, TResult data)
{
Severity = severity;
Data = data;
}
public Response(IEnumerable <Notification> notification, ESeverity severity, TResult data)
{
Notifications = notification;
Severity = severity;
Data = data;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log
/// </summary>
/// <param name="writer">le textwriter pour la sortie des logs</param>
/// <param name="dateFormat">le format des dates de timestamp</param>
/// <param name="filter">le niveau de filtrage pour la sortie des logs</param>
/// -----------------------------------------------------------------------------
protected BaseLogger(TextWriter writer, string dateFormat, ESeverity filter)
{
StringFormat = ConfigTagStart + ETags.TIMESTAMP + ConfigTagEnd + " " + ConfigTagStart + ETags.SEVERITY + ConfigTagEnd + " [" + ConfigTagStart + ETags.TYPE + ConfigTagEnd + "] " + ConfigTagStart + ETags.MESSAGE + ConfigTagEnd;
Enabled = true;
Writer = writer;
DateFormat = dateFormat;
Filter = filter;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose
/// </summary>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public virtual void Log(object sender, string message, ESeverity severity)
{
if (Logger != null)
{
Logger.Log(sender, message, severity);
}
if (GlobalLogger != null)
{
GlobalLogger.Log(sender, message, severity);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public virtual void Log(object sender, string message, ESeverity severity)
{
if ((Enabled) && (severity >= Filter) && (Writer != null))
{
// Remplacement des id chaines de ETags en leur équivalent integer
string format = StringFormat;
foreach (ETags tag in Enum.GetValues(typeof(ETags)))
format = format.Replace(tag.ToString(), Convert.ToInt32(tag).ToString(CultureInfo.InvariantCulture));
Writer.WriteLine(format, DateTime.Now.ToString(DateFormat), severity, sender.GetType().Name, message);
Writer.Flush();
}
}
public override void Log(object sender, string message, ESeverity severity)
{
_context.WriteLine("[{0}] {1} {2}", severity, sender.GetType().Name, message);
}
public void Log(ESeverity level, string message)
{
loggerDao.AddLog(Convert.ToInt32(level), message.Replace(Environment.NewLine, " "));
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log vierge
/// </summary>
/// -----------------------------------------------------------------------------
protected BaseLogger ()
{
Filter = ESeverity.DEBUG;
DateFormat = "dd/MM/yyyy HH:mm:ss";
StringFormat = ConfigTagStart + ETags.TIMESTAMP + ConfigTagEnd + " " + ConfigTagStart + ETags.SEVERITY + ConfigTagEnd + " [" + ConfigTagStart + ETags.TYPE + ConfigTagEnd + "] " + ConfigTagStart + ETags.MESSAGE + ConfigTagEnd;
Enabled = true;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur pour un log
/// </summary>
/// <param name="dateFormat">le format des dates de timestamp</param>
/// <param name="filter">le niveau de filtrage pour la sortie des logs</param>
/// -----------------------------------------------------------------------------
public NullConsoleLogger (string dateFormat, ESeverity filter)
{
DateFormat = dateFormat;
Filter = filter;
}
public void Log(string message, ESeverity severity)
{
Log(this, message, severity);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log: non supportée
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public override void Log (object sender, string message, ESeverity severity)
{
throw new NotSupportedException();
}
public DCIMessage(ESeverity severity, string message)
{
Severity = severity;
Message = message;
}
/// <summary>
/// Aggiunge messaggio di tipo impostabile senza nome campo UI
/// </summary>
/// <param name="code"></param>
/// <param name="message"></param>
/// <param name="severity"></param>
public void Add(int code, string message, ESeverity severity)
{
this.Add(code, message, severity, string.Empty);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera actif que pour une sévérité à ERREUR
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public override void Log(object sender, string message, ESeverity severity)
{
_context.WriteLine("[{0}] {1} {2}", severity, sender.GetType().Name, message);
}
public override void Log(object sender, string message, ESeverity severity)
{
throw new NotSupportedException();
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera actif que pour une sévérité à ERREUR
/// </summary>
/// <param name="sender">l'emetteur</param>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public override void Log(object sender, string message, ESeverity severity)
{
if ((severity == ESeverity.ERROR) && (_guiclient != null) && (_guiclient.MainComponent != null) &&
(_guiclient.MainComponent.NotifyIcon != null))
_guiclient.MainComponent.NotifyIcon.ShowBalloonTip(_timeout, _tipTitle, message, ToolTipIcon.Error);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Ecriture d'une entrée de log. Ne sera pas prise en compte si le log est inactif
/// ou si le filtre l'impose
/// </summary>
/// <param name="message">le message à logger</param>
/// <param name="severity">la sévérité</param>
/// -----------------------------------------------------------------------------
public void Log(string message, ESeverity severity)
{
Log(this, message, severity);
}