public void LogString(string message, Logtype type)
{
switch (type)
{
case Logtype.Wcc:
case Logtype.Normal:
_logger.LogDebug(message);
break;
case Logtype.Success:
_logger.LogInformation(message);
break;
case Logtype.Important:
_logger.LogWarning(message);
break;
case Logtype.Warning:
_logger.LogError(message);
break;
case Logtype.Error:
_logger.LogCritical(message);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public void LogString(string msg, Logtype type)
{
switch (type)
{
case Logtype.Normal:
s_log.Info(msg);
break;
case Logtype.Error:
s_log.Error(msg);
break;
case Logtype.Important:
s_log.Warning(msg);
break;
case Logtype.Success:
s_log.Info(msg);
break;
case Logtype.Wcc:
s_log.Info(msg);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
private void AddText(string text, Logtype type = Logtype.Normal)
{
switch (type)
{
case Logtype.Error:
txOutput.AppendText(text, Color.Red, false);
break;
case Logtype.Important:
txOutput.AppendText(text, Color.Orange, false);
break;
case Logtype.Wcc:
txOutput.AppendText(text);
break;
case Logtype.Success:
txOutput.AppendText(text, Color.LimeGreen, false);
break;
default:
txOutput.AppendText("[" + DateTime.Now.ToString("G") + "]: " + text);
break;
}
txOutput.ScrollToCaret();
}
public void AddText(string text, Logtype type = Logtype.Normal)
{
switch (type)
{
case Logtype.Error:
txOutput.AppendText(text, Color.DarkRed);
break;
case Logtype.Important:
txOutput.AppendText(text, Color.DarkBlue);
break;
case Logtype.Wcc:
txOutput.AppendText(text, Color.DarkOrchid);
break;
case Logtype.Success:
txOutput.AppendText(text, Color.LimeGreen);
break;
default:
txOutput.AppendText(text, Color.White);
break;
}
txOutput.ScrollToCaret();
}
public static DataSet SelectLog(DateTime st, DateTime et, Logtype logtype)
{
string strst = st.ToString("s");
string stret = et.ToString("s");
int f = (int)logtype;
DataSet dt = laidian.DbHelperSQL.Query("select * from all_log where logtype=" + f.ToString() + " and logdate<='" + stret + "' and logdate>='" + strst + "' order by logdate desc");
return(dt);
}
public void LogString(string msg, Logtype type)
{
var x = new LogEntry(msg, type);
if (_log.Count > Limit)
{
_log.RemoveAt(0);
}
_log.Add(x);
}
public static void insertLog(string slog, Logtype flag)
{
try
{
int f = (int)flag;
//laidian.DbHelperSQL.ExecuteSql("insert into all_log(logdate,logdesc,logtype)values('" + DateTime.Now.ToString("s") + "','" + slog + "'," + f.ToString() + ")");
}
catch
{ }
}
private void InternalLog(Logtype type, string text, params object[] args)
{
#if !UNITY_IOS
if (_loggerService == null)
{
return;
}
switch (type)
{
case Logtype.Info:
if (args != null && args.Length > 0)
{
_loggerService.LogFormat(text, args);
}
else
{
_loggerService.Log(text);
}
break;
case Logtype.Warning:
if (args != null && args.Length > 0)
{
_loggerService.LogWarningFormat(text, args);
}
else
{
_loggerService.LogWarning(text);
}
break;
case Logtype.Exception:
if (args != null && args.Length > 0)
{
_loggerService.LogExceptionFormat(text, args);
}
else
{
_loggerService.LogException(text);
}
break;
}
#endif
}
private void AddText(string text, Logtype type = Logtype.Normal)
{
var theme = ThemeManager.Current.DetectTheme(Application.Current);
var errorColor = Colors.Red.ToString();
var importantColor = Colors.Orange.ToString();
var successColor = Colors.LimeGreen.ToString();
var defaultColor = Colors.WhiteSmoke.ToString();
if (theme == null)
{
defaultColor = Colors.Black.ToString();
}
if (theme != null && theme.BaseColorScheme == "Light")
{
errorColor = Colors.Red.ToString();
importantColor = Colors.Orange.ToString();
successColor = Colors.Green.ToString();
defaultColor = Colors.Black.ToString();
}
var color = defaultColor;
switch (type)
{
case Logtype.Error:
color = errorColor;
break;
case Logtype.Important:
color = importantColor;
break;
case Logtype.Success:
color = successColor;
break;
case Logtype.Normal:
case Logtype.Wcc:
default:
break;
}
// LogRichTextBox.Invoke(() => LogRichTextBox.AppendText(text, color));
}
public void LogText(string message, Logtype logtype)
{
string line;
if (logtype < Loglevel)
{
return;
}
lock (this)
{
switch (logtype)
{
case Logtype.Debug:
line = DateTime.Now + " Debug: " + message;
Console.WriteLine(line);
System.IO.File.AppendAllText(logfilePath, line + Environment.NewLine);
break;
case Logtype.Info:
line = DateTime.Now + " Info: " + message;
Console.WriteLine(line);
System.IO.File.AppendAllText(logfilePath, line + Environment.NewLine);
break;
case Logtype.Warning:
line = DateTime.Now + " Warning: " + message;
Console.WriteLine(line);
System.IO.File.AppendAllText(logfilePath, line + Environment.NewLine);
break;
case Logtype.Error:
line = DateTime.Now + " Error: " + message;
Console.WriteLine(line);
System.IO.File.AppendAllText(logfilePath, line + Environment.NewLine);
break;
default:
line = DateTime.Now + " Unknown: " + message;
Console.WriteLine(line);
System.IO.File.AppendAllText(logfilePath, line + Environment.NewLine);
break;
}
}
}
/// <summary>
/// Logs a given exception
/// whoLoggs should be set to a reference to the object that wants to log
/// logtype is LogType (Debug, Info, Warning, Error)
/// </summary>
/// <param name="ex"></param>
/// <param name="whoLoggs"></param>
/// <param name="logtype"></param>
public void LogException(Exception ex, object whoLoggs, Logtype logtype)
{
if (logtype < Loglevel)
{
return;
}
lock (this)
{
switch (logtype)
{
case Logtype.Debug:
Console.WriteLine("{0} {1} {2}: Stacktrace:", DateTime.Now, "Debug", whoLoggs != null ? whoLoggs.GetType().FullName + "-" + whoLoggs.GetHashCode() : "null");
Console.WriteLine(ex.StackTrace);
break;
case Logtype.Info:
Console.WriteLine("{0} {1} {2}: Stacktrace:", DateTime.Now, "Info", whoLoggs != null ? whoLoggs.GetType().FullName + "-" + whoLoggs.GetHashCode() : "null");
Console.WriteLine(ex.StackTrace);
break;
case Logtype.Warning:
Console.WriteLine("{0} {1} {2}: Stacktrace:", DateTime.Now, "Warning", whoLoggs != null ? whoLoggs.GetType().FullName + "-" + whoLoggs.GetHashCode() : "null");
Console.WriteLine(ex.StackTrace);
break;
case Logtype.Error:
Console.WriteLine("{0} {1} {2}: Stacktrace:", DateTime.Now, "Error", whoLoggs != null ? whoLoggs.GetType().FullName + "-" + whoLoggs.GetHashCode() : "null");
Console.Error.WriteLine(ex.StackTrace);
break;
default:
Console.WriteLine("{0} {1} {2}: Stacktrace:", DateTime.Now, "Unknown", whoLoggs != null ? whoLoggs.GetType().FullName + "-" + whoLoggs.GetHashCode() : "null");
Console.WriteLine(ex.StackTrace);
break;
}
OnLoggOccured(String.Format("{0} {1}: Stacktrace: {2}", (whoLoggs != null ? whoLoggs.GetType().FullName : "null"), ex.Message, ex.StackTrace), logtype);
}
}
private static void AddToDB(Logtype log, string message, Type classdetails, int userid, Exception exception = null, string details = null)
{
try
{
NLogger.logger.FileLogger("Testing File Logger");
string assemblyName = classdetails.Assembly.FullName;
string className = classdetails.Name;
string ex = JsonConvert.SerializeObject(exception);
var connection = new SqlConnection(connectionString);
SqlParameter[] parameters = new SqlParameter[] {
new SqlParameter("@logtype", Enum.GetName(typeof(Logtype), log)),
new SqlParameter("@classinfo", className),
new SqlParameter("@asseblyinfo", assemblyName),
new SqlParameter("@message", message),
new SqlParameter("@userid", userid),
new SqlParameter("@exception", ex),
new SqlParameter("@data", details),
};
var result =
SqlHelper.ExecuteNonQuery
(
connection,
CommandType.StoredProcedure,
"usp_WriteToDB",
parameters
);
if (result > 0)
{
return;
}
}
catch (Exception ex)
{
NLogger.logger.FileLogger(ex.Message);
}
}
private Brush GetBrushForLevel(Logtype level)
{
switch (level)
{
case Logtype.Normal:
case Logtype.Wcc:
return(Brushes.Wheat);
case Logtype.Error:
return(Brushes.Red);
case Logtype.Important:
return(Brushes.Yellow);
case Logtype.Success:
return(Brushes.ForestGreen);
case Logtype.Warning:
return(Brushes.DarkViolet);
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
/// <summary>
/// Set minimum loglevel (default = info)
/// means, that only messages with level info or higher will be logged
/// </summary>
/// <param name="loglevel"></param>
public static void SetLogLevel(string part, Logtype loglevel)
{
Loglevel = loglevel;
filename = part;
//logfilePath = adfgvxCT2.Properties.Settings.Default.logfile + filename + DateTime.Now.ToString("yyyyMMddHHmmss") + ".txt";
}
public LogMessageEventArgs(string logMessage, DateTime logTime, Logtype logType)
{
_logMessage = logMessage;
_logTime = logTime;
_logType = logType;
}
public void Log(string msg, Logtype type = Logtype.Normal) => LogString(msg, type);
/// <summary>
/// Runs wcc_lite with specified arguments
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public async Task <int> RunCommand(string cmdName, string args)
{
string wccPath = _wccPath;
EWccStatus status = EWccStatus.NotRun;
using (Process process = new Process())
{
try
{
_logger.LogString($"-----------------------------------------------------", Logtype.Important);
_logger.LogString($"WCC_TASK: {args}", Logtype.Important);
process.StartInfo.FileName = wccPath;
process.StartInfo.WorkingDirectory = Path.GetDirectoryName(wccPath);
process.StartInfo.Arguments = args;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.CreateNoWindow = true;
using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false))
{
process.OutputDataReceived += (sender, e) =>
{
if (e.Data == null)
{
outputWaitHandle.Close();
//Handle Errors
if (_logger.ErrorLog.Any(x => x.Flag == WccLogFlag.WLF_Error) &&
_logger.ErrorLog.Any(x => x.Value.Contains("Wcc operation failed")))
{
_logger.LogString("Did not complete.\r\n", Logtype.Error);
status = EWccStatus.NotRun;
}
else if (_logger.ErrorLog.Any(x => x.Flag == WccLogFlag.WLF_Error))
{
_logger.LogString("Finished with Errors.\r\n", Logtype.Error);
status = EWccStatus.Error;
}
else if (_logger.ErrorLog.Any(x => x.Flag == WccLogFlag.WLF_Warning))
{
_logger.LogString("Finished with Warnings.\r\n", Logtype.Important);
status = EWccStatus.Finished;
}
else
{
_logger.LogString("Finished succesfully.\r\n", Logtype.Success);
status = EWccStatus.Finished;
}
}
else
{
_logger.LogExtended(SystemLogFlag.SLF_Interpretable, ToolLogFlag.TLF_Wcc, cmdName, $"{e.Data}");
Logtype wkitflag = Logtype.Wcc;
if (_logger.ErrorLog.Count > 0)
{
var flag = _logger.ErrorLog.Last().Flag;
switch (flag)
{
case WccLogFlag.WLF_Error: wkitflag = Logtype.Error;
break;
case WccLogFlag.WLF_Warning: wkitflag = Logtype.Important;
break;
case WccLogFlag.WLF_Default:
case WccLogFlag.WLF_Info:
default:
break;
}
}
_logger.LogString(e.Data, wkitflag);
}
};
process.Start();
process.BeginOutputReadLine();
process.WaitForExit();
}
if (status != EWccStatus.NotRun)
{
return(1);
}
else
{
return(0);
}
}
catch (Exception ex)
{
_logger.LogString(ex.ToString(), Logtype.Error);
throw ex;
}
}
}
public LogStringEventArgs(string message, Logtype logtype)
{
Message = message;
Logtype = logtype;
}
public static void WriteLog(Logtype log, string message, int userid, Type classdetails, object data)
{
string details = JsonConvert.SerializeObject(data);//(json)data;
AddToDB(log, message, classdetails, userid, null, details);
}
public static ERPEmployee_checkin Create(string employeename, string employee, Logtype logtype, string time)
{
ERPEmployee_checkin obj = new ERPEmployee_checkin();
obj.employee_name = employeename;
obj.employee = employee;
obj.log_type = logtype;
obj.time = time;
return(obj);
}
public static void WriteLog(Logtype log, string message, int userid, Type classdetails, Exception exception)
{
AddToDB(log, message, classdetails, userid, exception);
}
public LogEntry(string message, Logtype level, DateTime timeStamp)
{
Message = message;
Level = level;
TimeStamp = timeStamp;
}
private void AddTextStatic(string text, Logtype type = Logtype.Normal)
{
Invoke(new logDelegate(AddText), text, type);
}
/// <summary>
/// Log an string
/// </summary>
/// <param name="value"></param>
public void LogString(string value, Logtype type = Logtype.Normal)
{
Logtype = type;
Log = value;// + "\r\n";
OnPropertyChanged(nameof(Log));
}
public LogEntry(string message, Logtype level)
{
Message = message;
Level = level;
}
/// <summary>
/// Creates a new LogEventArgs
/// </summary>
/// <param name="logtype"></param>
/// <param name="message"></param>
public LogEventArgs(Logtype logtype, string message)
{
Logtype = logtype;
Message = message;
}
public void Log(string msg, Logtype type = Logtype.Normal) => throw new NotImplementedException();
