protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
if (log.TargetType != typeof(TestLogListener))
{
return;
}
switch (logEvent)
{
case LogEvent.Debug:
DebugCount++;
break;
case LogEvent.Info:
InfoCount++;
break;
case LogEvent.Warning:
WarningCount++;
break;
case LogEvent.Error:
ErrorCount++;
break;
case LogEvent.Status:
StatusCount++;
break;
}
}
public void Save_WriteBananaToFile_Test()
{
LogData logData = new LogData();
logData.Category = "Fruta";
logData.LogType = "Erro";
logData.ObjectToLog = "Banana";
logData.MethodName = "Save_WriteBanana_To_File";
ConfigurationUtilityMock mock = new ConfigurationUtilityMock();
mock.LogPath = "c:/BananaDePijama";
mock.LogType = "File";
IocFactory.Register(
Component.For<IConfigurationUtility>()
.Instance(mock),
Component.For<ILog>()
.ImplementedBy<FileLogProcessor>()
.Interceptor<LogInterceptor>()
);
ILog log = IocFactory.Resolve<ILog>();
log.Save(logData);
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, System.DateTime time)
{
base.Write(log, message, logEvent, extraData, time);
switch (logEvent)
{
case LogEvent.Debug:
_eventSource.Debug(message);
break;
case LogEvent.Info:
_eventSource.Info(message);
break;
case LogEvent.Warning:
_eventSource.Warning(message);
break;
case LogEvent.Error:
_eventSource.Error(message);
break;
default:
throw new ArgumentOutOfRangeException("logEvent");
}
}
public void Post(LogData data)
{
data.User = GetCurrentSession().User;
var log = GetLog(data);
var @event = CreateEvent(data, log);
SaveMeasurements(data.User, log, @event, data.Measurements);
SaveTags(log, data.User, @event, data.Tags);
}
/// <summary>
/// Writes the specified LogData to NLog.
/// </summary>
/// <param name="logData">The log data.</param>
public static void WriteLog(LogData logData)
{
var logEvent = logData.ToLogEvent();
var name = logData.Logger ?? typeof(NLogWriter).FullName;
var logger = global::NLog.LogManager.GetLogger(name);
logger.Log(logEvent);
}
protected override bool ShouldIgnoreLogMessage(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
if (message.StartsWith("Uninitialized"))
{
return true;
}
return false;
}
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
_textBox.Dispatcher.Invoke(() =>
{
_textBox.AppendText(string.Format("{0} {1}", time.ToString("HH:mm:ss.fff"), message));
_textBox.AppendText(Environment.NewLine);
_textBox.ScrollToEnd();
});
}
/// <summary>
/// Initializes a new instance of the <see cref="LogMessageEventArgs" /> class.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="extraData">The extra data.</param>
/// <param name="logData">The log data.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="time">The time.</param>
public LogMessageEventArgs(ILog log, string message, object extraData, LogData logData, LogEvent logEvent, DateTime time)
{
Log = log;
Time = time;
Message = message;
ExtraData = extraData;
LogEvent = logEvent;
LogData = logData;
}
public void Save(LogData logData)
{
EventLog log = new EventLog();
log.Source = "Troco$erto";
string logMessage = Serializer.JsonSerialize(logData.ObjectToLog);
log.WriteEntry(logMessage, EventLogEntryType.Information);
}
private Log GetLog(LogData data)
{
var log = LogRepository.Name(data.Name);
if (log == null)
{
log = new Log { Id = Guid.NewGuid(), Name = data.Name, UserId = data.User.Id };
LogRepository.Create(log);
}
return log;
}
public Reverse(Stage stage, Game1 game, ContentManager content)
{
this.game = game;
this.stage = stage;
this.content = content;
nowlogdata = new LogData();
reverseLog = new List<LogData>();
score_prev = 0;
tasSound = content.Load<SoundEffect>("Audio\\SE\\TAS");
}
/// <summary>
/// メッセージを記録する
/// </summary>
/// <param name="message"></param>
public void LogMessage(string message)
{
if (_saveLog) {
LogData data = new LogData(LogData.LogType.Message, message);
Loglist.Add(data);
DebugWrite(message);
}
}
private static void WriteLog(LogData logData, Action<object> logAction, Action<object, Exception> errorAction)
{
bool isFormatted = logData.Parameters != null && logData.Parameters.Length > 0;
string message = isFormatted
? string.Format(logData.FormatProvider, logData.Message, logData.Parameters)
: logData.Message;
if (logData.Exception == null)
logAction(message);
else
errorAction(message, logData.Exception);
}
public static void Log( LogData playClipData )
{
playClipData.time = Time.time;
if ( logData.Count >= 1024 )
{
logData.RemoveLast();
}
logData.AddFirst( playClipData );
_OnLogUpdated();
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
lock (_lock)
{
_logBatch.Add(new LogBatchEntry(log, message, logEvent, extraData, logData, time));
if (_logBatch.Count >= MaximumBatchCount)
{
// TODO: remove pragma in 5.0.0
#pragma warning disable 4014
Flush();
#pragma warning restore 4014
}
}
}
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
_textBox.Dispatcher.Invoke(() =>
{
var finalMessage = string.Format("{0} {1}", time.ToString("hh:mm:ss.fff"), message);
var paragraph = new Paragraph(new Run(finalMessage));
FixParagraphSpacing(paragraph);
paragraph.Foreground = ColorSets[logEvent];
_textBox.Document.Blocks.Add(paragraph);
_textBox.ScrollToEnd();
});
}
public LogDump(LogData data)
{
if (data != null)
{
this.StationName = data.SolutionName;
this.NumberOfBuildsFailed = data.NumberOfBuildsFailed;
this.NumberOfBuildsSucceeded = data.NumberOfBuildsSucceeded;
this.NumberOfProjectsBuilt = data.NumberOfProjectsBuilt;
this.NumberOfTestsFailed = data.NumberOfTestsFailed;
this.NumberOfTestsIgnored = data.NumberOfTestsIgnored;
this.NumberOfTestsPassed = data.NumberOfTestsPassed;
this.NumberOfTestsRan = data.NumberOfTestsRan;
this.StationName = data.StationName;
this.TimeStamp = data.TimeStamp;
this.UserName = data.UserName;
}
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The extra data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
base.Write(log, message, logEvent, extraData, time);
var logEntry = new LogEntry(log, message, logEvent, extraData, null, time);
AddLogEvent(_lastLogEntries, logEntry, MaximumNumberOfLogEntries);
switch (logEvent)
{
case LogEvent.Warning:
AddLogEvent(_lastWarningLogEntries, logEntry, MaximumNumberOfWarningLogEntries);
break;
case LogEvent.Error:
AddLogEvent(_lastErrorLogEntries, logEntry, MaximumNumberOfErrorLogEntries);
break;
}
}
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
if (string.Equals(log.Tag, "Orc.CommandLine.CommandLineParser"))
{
return;
}
if (logEvent == LogEvent.Error)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (logEvent == LogEvent.Warning)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("{0}", message);
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
string consoleMessage = FormatLogEvent(log, message, logEvent, extraData, time);
#if NET
var oldConsoleBackgroundColor = Console.BackgroundColor;
var oldConsoleForegroundColor = Console.ForegroundColor;
UpdateConsoleColors(logEvent);
#endif
#if NETFX_CORE || PCL
System.Diagnostics.Debug.WriteLine(consoleMessage);
#else
Console.WriteLine(consoleMessage);
#endif
#if NET
Console.BackgroundColor = oldConsoleBackgroundColor;
Console.ForegroundColor = oldConsoleForegroundColor;
#endif
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, System.DateTime time)
{
base.Write(log, message, logEvent, extraData, time);
switch (logEvent)
{
case LogEvent.Debug:
_eventSource.Debug(message);
break;
case LogEvent.Info:
_eventSource.Info(message);
break;
case LogEvent.Warning:
_eventSource.Warning(message);
break;
case LogEvent.Error:
_eventSource.Error(message);
break;
}
}
/// <summary>
/// Writes the specified LogData to log4net.
/// </summary>
/// <param name="logData">The log data.</param>
public static void WriteLog(LogData logData)
{
var name = logData.Logger ?? typeof(Log4NetWriter).FullName;
var logger = LogManager.GetLogger(name);
switch (logData.LogLevel)
{
case LogLevel.Info:
if (logger.IsInfoEnabled)
WriteLog(logData, logger.Info, logger.Info);
break;
case LogLevel.Warn:
if (logger.IsWarnEnabled)
WriteLog(logData, logger.Warn, logger.Warn);
break;
case LogLevel.Error:
if (logger.IsErrorEnabled)
WriteLog(logData, logger.Error, logger.Error);
break;
case LogLevel.Fatal:
if (logger.IsFatalEnabled)
WriteLog(logData, logger.Fatal, logger.Fatal);
break;
default:
if (logger.IsDebugEnabled)
WriteLog(logData, logger.Debug, logger.Debug);
break;
}
}
public string Log(LogData data)
{
// Get the appropriate logger.
ILog logger = _log;
if (IsNonBlank(data.Logger))
{
logger = LogManager.GetLogger(data.Logger);
}
// Construct the log message.
StringBuilder sb = new StringBuilder("ClientLog: ").Append(data.Message);
if (IsNonBlank(data.TriedTo))
{
sb.Append(Environment.NewLine).Append(" - While attempting to ").Append(data.TriedTo);
}
var level = (IsNonBlank(data.Level) ? data.Level.ToUpper() : "INFO");
if (level != "DEBUG" && level != "INFO")
{
// Add user agent for more severe messages
var userAgent = ControllerContext.HttpContext.Request.UserAgent;
sb.Append(Environment.NewLine).Append(" - UserAgent: ").Append(userAgent);
}
// Now log it at the appropriate level.
var message = sb.ToString();
switch (level)
{
case "DEBUG": logger.Debug(message); break;
case "INFO" : logger.Info(message); break;
case "WARN" : logger.Warn(message); break;
case "ERROR": logger.Error(message); break;
default:
case "FATAL": logger.Fatal(message); break;
}
return "OK";
}
public void Save(LogData logData)
{
IConfigurationUtility configurationUtility = IocFactory.Resolve<IConfigurationUtility>();
string fileName = DateTime.Now.ToString("yyyy-MM-dd") + ".log";
string filePath = configurationUtility.LogPath;
if (Directory.Exists(filePath) == false) {
Directory.CreateDirectory(filePath);
}
string log = string.Format("[{0}] {1} | {2} | {3} | {4} \r\n",
DateTime.Now, logData.LogType, logData.MethodName, logData.Category, Serializer.JsonSerialize(logData.ObjectToLog));
string fullPath = Path.Combine(filePath, fileName);
FileStream logFile = File.Open(fullPath, FileMode.Append, FileAccess.Write);
byte[] logByteArray = log.GetBytes();
logFile.Write(logByteArray, 0, logByteArray.Length);
logFile.Close();
}
/// <summary>
/// Opdaterer F*g/Kursus forløb hørende til ét uddannelsesforløb specificeret ved id, UserName og
/// Password.
/// </summary>
/// <remarks>
/// UserName og Password skal være gemt i Web API'ets database for at være gyldige.
/// </remarks>
/// <param name="json_Object">json_Objekt er et objekt i jSon format. Det skal indeholde
/// data til funktionen med følgende felter specificeret : User_Education_Time_CollectionID,
/// CourseID.
/// Optionalt kan følgende felter også angives : WhichCharacterScaleID, CharacterValueCourse og
/// AbsencePercentageCourse
/// </param>
/// <param name="id">Integer der specificerer id på Bruger-F*g/Kursus samling.</param>
/// <param name="Password">Password for nuværende bruger.</param>
/// <param name="UserName">Brugernavn for nuværende bruger.</param>
/// <returns>
/// UpdateOperationOk (værdien 1) hvis F*g/Kursus forløb er gemt ok.
/// Eller en retur kode med en værdi mindre end 0, hvis noget gik galt.
/// Se en oversigt over return koder i ReturnCodesAndStrings eller klik
/// her : <see cref="ReturnCodeAndReturnString"/>
/// </returns>
// PUT api/<controller>/5
public int Put(int id, dynamic json_Object, string UserName, string Password)
{
User_Education_Character_Course_Collection User_Education_Character_Course_Collection_Object =
new User_Education_Character_Course_Collection();
WhichCharacterScale WhichCharacterScale_Object = new WhichCharacterScale();
int NumberOfCourseCharactersSaved;
int UserID = 0;
UserID = UserInfo.FindUserInDatabase(UserName, Password);
if (Const.UserNotFound < UserID)
{
if ((null == json_Object.User_Education_Time_CollectionID) ||
(null == json_Object.CourseID))
{
return(Const.WrongjSonObjectParameters);
}
else
{
User_Education_Character_Course_Collection_Object = db.User_Education_Character_Course_Collections.Find(id);
if (null != User_Education_Character_Course_Collection_Object)
{
if (User_Education_Character_Course_Collection_Object.User_Education_Time_Collection.UserInfoID != UserID)
{
return(Const.ObjectNotSavedByCurrentUserOriginally);
}
User_Education_Character_Course_Collection_Object.User_Education_Time_CollectionID =
json_Object.User_Education_Time_CollectionID;
User_Education_Character_Course_Collection_Object.CourseID =
json_Object.CourseID;
if (null != json_Object.WhichCharacterScaleID)
{
WhichCharacterScale_Object = db.WhichCharacterScales.Find((int)json_Object.WhichCharacterScaleID);
if (null == WhichCharacterScale_Object)
{
return(Const.WrongCharacterScaleProvided);
}
User_Education_Character_Course_Collection_Object.WhichCharacterScaleID = json_Object.WhichCharacterScaleID;
}
else
{
User_Education_Character_Course_Collection_Object.WhichCharacterScaleID = null;
}
if (null != json_Object.CharacterValueCourse)
{
if (null == json_Object.WhichCharacterScaleID)
{
return(Const.CharacterProvidedButNoCharacterScaleProvided);
}
else
{
int WhichCharacterScale = WhichCharacterScale_Object.WhichCharacterScaleID;
int CharacterValueCourse = json_Object.CharacterValueCourse;
switch (WhichCharacterScale)
{
case (int)WhichCharacterScaleENUM.Character_7_ENUM:
Character7Scale Character7Scale_Object = db.Character7Scales.FirstOrDefault(c => c.Character7ScaleValue == CharacterValueCourse);
if (null == Character7Scale_Object)
{
return(Const.WrongCharacterProvided);
}
break;
case (int)WhichCharacterScaleENUM.Character_13_ENUM:
Character13Scale Character13Scale_Object = db.Character13Scales.FirstOrDefault(c => c.Character13ScaleValue == CharacterValueCourse);
if (null == Character13Scale_Object)
{
return(Const.WrongCharacterProvided);
}
break;
}
}
User_Education_Character_Course_Collection_Object.CharacterValueCourse = json_Object.CharacterValueCourse;
}
else
{
if (null != json_Object.WhichCharacterScaleID)
{
return(Const.NoCharacterProvidedButCharacterScaleProvided);
}
User_Education_Character_Course_Collection_Object.CharacterValueCourse = null;
}
if (null != json_Object.AbsencePercentageCourse)
{
User_Education_Character_Course_Collection_Object.AbsencePercentageCourse = json_Object.AbsencePercentageCourse;
}
else
{
User_Education_Character_Course_Collection_Object.AbsencePercentageCourse = null;
}
NumberOfCourseCharactersSaved = db.SaveChanges();
if (1 == NumberOfCourseCharactersSaved)
{
LogData.LogDataToDatabase(UserName, DataBaseOperation.UpdateData_Enum, ModelDatabaseNumber.User_Education_Character_Course_Collection_Enum);
return(Const.UpdateOperationOk);
}
else
{
return(Const.UpdateOperationFailed);
}
}
else
{
return(Const.ObjectNotFound);
}
}
}
else
{
return(Const.UserNotFound);
}
}
internal StatusRef(status value, LogData logData)
{
x = value; this.logData = logData;
}
private void PerformLog(LogEntry logEntry)
{
TelemetryClient telemetryClient = null;
IUserInformationProvider userInformationProvider = null;
bool isPerRequestTelemetryClient = false;
if (logEntry.LogData.Any(ld => ld.Key == nameof(IRequestInformationProvider.RequestUri)))
{
IOwinContext owinContext = OwinContext.Value;
IDependencyResolver resolver = owinContext.GetDependencyResolver();
telemetryClient = resolver.Resolve <TelemetryClient>();
userInformationProvider = resolver.Resolve <IUserInformationProvider>();
isPerRequestTelemetryClient = true;
}
List <KeyVal> keyValues = logEntry.LogData.Select(ld =>
{
string k = ld.Key;
if (k == nameof(IRequestInformationProvider.HttpMethod) ||
k == nameof(IRequestInformationProvider.RequestUri) ||
k == nameof(IRequestInformationProvider.UserAgent) ||
k == "UserId" ||
k == "ResponseStatusCode" ||
k == nameof(IRequestInformationProvider.ClientIp) ||
ld.Value == null)
{
return(null);
}
string v = null;
if (ld.Value is string valueAsStr)
{
v = valueAsStr;
}
if (k == "ClientLogs" || k == "OperationArgs")
{
v = Formatter.Serialize(ld.Value);
}
else
{
v = ld.Value.ToString();
}
return(new KeyVal {
Key = k, Value = v
});
})
.Where(d => d != null)
.ToList();
try
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppEnvironmentName), Value = logEntry.AppEnvironmentName
});
if (logEntry.AppServerProcessId.HasValue)
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerProcessId), Value = logEntry.AppServerProcessId.ToString()
});
}
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerAppDomainName), Value = logEntry.AppServerAppDomainName
});
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerOSVersion), Value = logEntry.AppServerOSVersion
});
if (logEntry.AppServerDateTime.HasValue)
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerDateTime), Value = logEntry.AppServerDateTime.ToString()
});
}
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerName), Value = logEntry.AppServerName
});
if (logEntry.AppWasInDebugMode.HasValue)
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppWasInDebugMode), Value = logEntry.AppWasInDebugMode.ToString()
});
}
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerUserAccountName), Value = logEntry.AppServerUserAccountName
});
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppVersion), Value = logEntry.AppVersion
});
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.ApplicationName), Value = logEntry.ApplicationName
});
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.Severity), Value = logEntry.Severity
});
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.Message), Value = logEntry.Message
});
if (logEntry.Id.HasValue)
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.Id), Value = logEntry.Id.ToString()
});
}
if (logEntry.AppServerThreadId.HasValue)
{
keyValues.Add(new KeyVal {
Key = nameof(LogEntry.AppServerThreadId), Value = logEntry.AppServerThreadId.ToString()
});
}
if (isPerRequestTelemetryClient == true)
{
if (userInformationProvider.IsAuthenticated())
{
telemetryClient.Context.User.AccountId = telemetryClient.Context.User.AuthenticatedUserId = userInformationProvider.GetCurrentUserId();
}
LogData userAgent = logEntry.LogData.FirstOrDefault(ld => ld.Key == nameof(IRequestInformationProvider.UserAgent));
if (userAgent != null)
{
telemetryClient.Context.User.UserAgent = (string)userAgent.Value;
}
foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key))
{
if (!telemetryClient.Context.Properties.ContainsKey(keyVal.Key))
{
telemetryClient.Context.Properties.Add(keyVal.Key, keyVal.Value);
}
}
}
else
{
telemetryClient = new TelemetryClient();
Dictionary <string, string> customData = new Dictionary <string, string>();
foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key))
{
if (!customData.ContainsKey(keyVal.Key))
{
customData.Add(keyVal.Key, keyVal.Value);
}
}
Exception ex = null;
try
{
customData.TryGetValue("ExceptionTypeAssemblyQualifiedName", out string exceptionTypeAssemblyQualifiedName);
if (!string.IsNullOrEmpty(exceptionTypeAssemblyQualifiedName))
{
ex = (Exception)Activator.CreateInstance(Type.GetType(exceptionTypeAssemblyQualifiedName), args: new object[] { logEntry.Message });
}
}
catch { }
if (ex == null)
{
switch (logEntry.Severity)
{
case "Information":
ex = new InformationException(logEntry.Message);
break;
case "Warning":
ex = new WarningException(logEntry.Message);
break;
case "Error":
ex = new ErrorException(logEntry.Message);
break;
case "Fatal":
ex = new FatalException(logEntry.Message);
break;
default:
ex = new Exception(logEntry.Message);
break;
}
}
telemetryClient.TrackException(ex, customData);
}
}
finally
{
telemetryClient.Flush();
}
}
public void Log(LogData logData)
{
throw new NotImplementedException();
}
public DpsReportUpload(LogData logData) : base(logData)
{
}
public async Task <int> Log(LogData log, CancellationToken token) => await logDataProcessor.LogAsync(log, token);
private static void WriteLog(LogData logData, Action <Exception, string, object[]> writer)
{
string message = FormatMessage(logData);
writer(logData.Exception, message, logData.Parameters);
}
/// <summary>
/// Raises the <see cref="LogMessage" /> event.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The extra data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected void RaiseLogMessage(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
var handler = LogMessage;
if (handler != null)
{
handler(this, new LogMessageEventArgs(log, message, extraData, logData, logEvent, time));
}
}
/// <summary>
/// Called when any message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected virtual void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
// Empty by default
}
/// <summary>
/// Called when a <see cref="LogEvent.Status" /> message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The ti me.</param>
void ILogListener.Status(ILog log, string message, object extraData, LogData logData, DateTime time)
{
if (IgnoreCatelLogging && log.IsCatelLogging)
{
return;
}
if (ShouldIgnoreLogMessage(log, message, LogEvent.Status, extraData, logData, time))
{
return;
}
Status(log, message, extraData, logData, time);
}
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
if (log.TargetType != typeof(TestLogListener))
{
return;
}
switch (logEvent)
{
case LogEvent.Debug:
DebugCount++;
break;
case LogEvent.Info:
InfoCount++;
break;
case LogEvent.Warning:
WarningCount++;
break;
case LogEvent.Error:
ErrorCount++;
break;
}
}
/// <inheritdoc/>
public override void Parse(LogData testResultsLine)
{
if (testResultsLine == null || testResultsLine.Message == null)
{
logger.Error("MochaTestResultParser : Parse : Input line was null.");
return;
}
try
{
this.stateContext.CurrentLineNumber = testResultsLine.LineNumber;
// State model for the mocha parser that defines the Regexs to match against in each state
// Each state re-orders the Regexs based on the frequency of expected matches
switch (this.currentState)
{
// This state primarily looks for test results
// and transitions to the next one after a line of summary is encountered
case MochaParserStates.ExpectingTestResults:
if (AttemptMatch(this.ExpectingTestResults, testResultsLine))
{
return;
}
break;
// This state primarily looks for test run summary
// If failed tests were found to be present transitions to the next one to look for stack traces
// else goes back to the first state after publishing the run
case MochaParserStates.ExpectingTestRunSummary:
if (AttemptMatch(this.ExpectingTestRunSummary, testResultsLine))
{
return;
}
break;
// This state primarily looks for stack traces
// If any other match occurs before all the expected stack traces are found it
// fires telemetry for unexpected behavior but moves on to the next test run
case MochaParserStates.ExpectingStackTraces:
if (AttemptMatch(this.ExpectingStackTraces, testResultsLine))
{
return;
}
break;
}
// This is a mechanism to enforce matches that have to occur within
// a specific number of lines after encountering the previous match
// one obvious usage is for successive summary lines containing passed,
// pending and failed test summary
if (this.stateContext.LinesWithinWhichMatchIsExpected == 1)
{
this.logger.Info($"MochaTestResultParser : Parse : Was expecting {this.stateContext.NextExpectedMatch} before line {testResultsLine.LineNumber}, but no matches occurred.");
AttemptPublishAndResetParser();
return;
}
// If no match occurred and a match was expected in a positive number of lines, decrement the counter
// A value of zero or lesser indicates not expecting a match
if (this.stateContext.LinesWithinWhichMatchIsExpected > 1)
{
this.stateContext.LinesWithinWhichMatchIsExpected--;
return;
}
}
catch (Exception e)
{
this.logger.Error($"MochaTestResultParser : Parse : Failed with exception {e}.");
// This might start taking a lot of space if each and every parse operation starts throwing
// But if that happens then there's a lot more stuff broken.
telemetry.AddToCumulativeTelemetry(MochaTelemetryConstants.EventArea, "Exceptions", new List <string> {
e.Message
});
// Rethrowing this so that the plugin is aware that the parser is erroring out
// Ideally this never should happen
throw;
}
}
public string getAreano(LogData Log)
{
return(Contestno.GetAreano(Log));
}
private void PerformLog(LogEntry logEntry)
{
if (DiagnosticContext == null || SerilogLogger == null)
{
throw new InvalidOperationException($"Configure asp.net core & serilog using https://github.com/serilog/serilog-aspnetcore");
}
bool isRequestLogEntry = false;
if (logEntry.LogData.Any(ld => ld.Key == nameof(IRequestInformationProvider.DisplayUrl)) && HttpContextAccessor.HttpContext != null)
{
isRequestLogEntry = true;
HttpContext httpContext = HttpContextAccessor.HttpContext;
IUserInformationProvider userInformationProvider = httpContext.RequestServices.GetRequiredService <IUserInformationProvider>();
}
var keyValues = logEntry.LogData.Select(ld =>
{
string k = ld.Key;
if (k == nameof(IRequestInformationProvider.HttpMethod) ||
k == nameof(IRequestInformationProvider.DisplayUrl) ||
k == "ResponseStatusCode" ||
ld.Value == null)
{
return(Key: null, Value: null); // Already being logged by serilog!
}
string v = null;
if (ld.Value is string valueAsStr)
{
v = valueAsStr;
}
if (k == "ClientLogs" || k == "OperationArgs")
{
v = Formatter.Serialize(ld.Value);
}
else
{
v = ld.Value.ToString();
}
return(Key: k, Value: v);
})
.Where(d => d.Key != null)
.ToList();
keyValues.Add((Key: nameof(LogEntry.MemoryUsage), Value: logEntry.MemoryUsage.ToString()));
if (logEntry.AppServerDateTime.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.AppServerDateTime), Value: logEntry.AppServerDateTime.ToString()));
}
keyValues.Add((Key: nameof(LogEntry.Severity), Value: logEntry.Severity));
keyValues.Add((Key: nameof(LogEntry.Message), Value: logEntry.Message));
if (logEntry.Id.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.Id), Value: logEntry.Id.ToString()));
}
if (logEntry.AppServerThreadId.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.AppServerThreadId), Value: logEntry.AppServerThreadId.ToString()));
}
foreach (var(Key, Value) in keyValues.OrderBy(kv => kv.Key))
{
DiagnosticContext.Set(Key, Value);
}
if (isRequestLogEntry == true)
{
LogData userAgent = logEntry.LogData.FirstOrDefault(ld => ld.Key == nameof(IRequestInformationProvider.UserAgent));
if (userAgent != null)
{
DiagnosticContext.Set("UserAgent", userAgent.Value);
}
}
else
{
Exception ex = null;
try
{
var(Key, Value) = keyValues.ExtendedSingleOrDefault("Finding ExceptionTypeAssemblyQualifiedName...", kv => kv.Key == "ExceptionTypeAssemblyQualifiedName");
if (!string.IsNullOrEmpty(Value))
{
ex = (Exception)Activator.CreateInstance(Type.GetType(Value) ?? throw new InvalidOperationException($"{Value} could not be found"), args: new object[] { logEntry.Message });
}
}
catch { }
LogEventLevel level = logEntry.Severity switch
{
"Information" => LogEventLevel.Information,
"Warning" => LogEventLevel.Warning,
"Error" => LogEventLevel.Error,
"Fatal" => LogEventLevel.Fatal,
_ => LogEventLevel.Debug,
};
SerilogLogger.Write(level, ex?.Message ?? logEntry.Message);
}
}
/// <summary>
/// Tells the OS to open the users desired editor as specified by the Unity editor preferences.
/// ONLY SUPPORTS VISUAL STUDIO AND VS CODE
/// </summary>
/// <param name="log">Message the user clicked on and is trying to open the source of</param>
void OpenEditor(LogData log)
{
var path = log.FilePath;
if (OS_Toggles[0])
{
string editor = EditorPrefs.GetString("kScriptsDefaultApp_h2657262712");
if (editor.Contains("devenv"))
{
var proc = Process.GetProcesses();
for (int i = 0; i < proc.Length; i++)
{
if (proc[i].ProcessName.Contains("devenv"))
{
Process.Start("devenv", "/Edit \"" + path);
return;
}
}
var rootDir = new DirectoryInfo(Directory.GetCurrentDirectory());
var sln = rootDir.GetFiles("*.sln");
Process.Start("devenv", "/UseEnv \"" + sln[0].FullName);
}
else
{
string fixedPath = FixPathSpaces(path);
string slnPath = FixPathSpaces(Directory.GetCurrentDirectory());
Process.Start("code", "-g " + fixedPath + ":" + log.LineNumber);
if (Process.GetProcessesByName("code") == null)
{
Process.Start("code", "--add " + slnPath);
}
}
}
else if (OS_Toggles[1])
{
#if UNITY_EDITOR_OSX
string fixedPathOSX = FixPathSpaces(path);
ProcessStartInfo s = new ProcessStartInfo()
{
FileName = "/Applications/Visual Studio Code.app/Contents/MacOS/Electron",
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardInput = true,
RedirectStandardOutput = true,
CreateNoWindow = true,
Arguments = "-g " + fixedPathOSX + ":" + log.LineNumber
};
string slnPathOSX = FixPathSpaces(Directory.GetCurrentDirectory());
s.Arguments += " --add " + slnPathOSX;
Process.Start(s);
return;
#endif
string fixedPathLinux = FixPathSpaces(path);
string slnPathLinux = FixPathSpaces(Directory.GetCurrentDirectory());
Process.Start("code", "-g " + fixedPathLinux + ":" + log.LineNumber);
if (Process.GetProcessesByName("code") == null)
{
Process.Start("code", "--add " + slnPathLinux);
}
}
}
void DrawConsoleWindow(int id)
{
Color defaultContentColor = GUI.contentColor;
GUIStyle buttonStyle = new GUIStyle("button");
buttonStyle.alignment = TextAnchor.MiddleLeft;
buttonStyle.fixedHeight = 30;
buttonStyle.margin = new RectOffset(0, 0, 0, 0);
GUI.contentColor = Color.white;
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
GUILayout.Label("Logs");
GUILayout.Space(20);
_filter = (LogFilter)GUILayout.SelectionGrid((int)_filter, Enum.GetNames(typeof(LogFilter)), Enum.GetValues(typeof(LogFilter)).Length);
GUILayout.EndHorizontal();
List <LogData> dataList = new List <LogData>(_logQueue.ToArray()).FindAll(m => _filter == LogFilter.All || m.type.GetFilter() == _filter);
int listItemHeight = (int)buttonStyle.fixedHeight; // TODO Use Margin.
int listScrollBottomPos = (listItemHeight * dataList.Count) - (int)_listScrollRect.height;
Vector2 scrollPos = new Vector2(_listScrollPosition.x, _autoListScroll ? listScrollBottomPos :_listScrollPosition.y);
_listScrollPosition = GUILayout.BeginScrollView(scrollPos, false, true, GUILayout.MaxHeight(_scrollHeight));
if (listScrollBottomPos <= _listScrollPosition.y)
{
_autoListScroll = true;
}
GUILayout.Box(GUIContent.none, GUIStyle.none, GUILayout.ExpandWidth(true), GUILayout.Height(0));
Rect listRect = GUILayoutUtility.GetLastRect();
GUI.contentColor = defaultContentColor;
foreach (LogData data in dataList)
{
GUI.contentColor = data.type.GetFilter().GetContentColor();
if (GUILayout.Button(data.condition, buttonStyle, GUILayout.Width(listRect.width), GUILayout.ExpandWidth(true)))
{
_selectedLogData = data;
}
GUI.contentColor = defaultContentColor;
}
GUILayout.EndScrollView();
Rect listLastRect = GUILayoutUtility.GetLastRect();
if (!(listLastRect.x == 0 && listLastRect.y == 0 && listLastRect.width == 1 && listLastRect.height == 1))
{
_listScrollRect = GUILayoutUtility.GetLastRect();
}
GUILayout.Space(10);
GUILayout.Label("Detail");
_detailScrollPosition = GUILayout.BeginScrollView(_detailScrollPosition, false, true, GUILayout.MaxHeight(_scrollHeight));
if (_selectedLogData != null)
{
GUI.contentColor = _selectedLogData.type.GetFilter().GetContentColor();
GUILayout.Label(_selectedLogData.condition + "\n" + _selectedLogData.stackTrace);
GUI.contentColor = defaultContentColor;
}
GUILayout.EndScrollView();
_detailScrollRect = GUILayoutUtility.GetLastRect();
GUILayout.Space(10);
// Export Menu
GUILayout.BeginHorizontal();
GUI.contentColor = defaultContentColor;
if (_selectedLogData == null)
{
GUI.contentColor = Color.gray;
GUILayout.Button("Log Export (Select a Log!)");
}
else
{
if (GUILayout.Button("Log Export"))
{
ExportLog(_selectedLogData);
}
}
GUI.contentColor = defaultContentColor;
GUILayout.EndHorizontal();
// Clear & Close
GUILayout.BeginHorizontal();
if (GUILayout.Button("Clear"))
{
_selectedLogData = null;
_logQueue = new Queue <LogData>();
}
if (GUILayout.Button("Close"))
{
isShow = false;
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUI.DragWindow(new Rect(0, 0, _consoleRect.width, 30));
GUI.contentColor = defaultContentColor;
}
private Rollbar.Classes.JsonRollbarRootObject CreateDataToSend(RollbarSettings settings, LogData LogMessage)
{
var jdatabody = new Rollbar.Classes.Body()
{
message = new Classes.Message {
body = LogMessage.Exception.ToString()
}
};
var jdataperson = new Rollbar.Classes.Person()
{
email = SettingsInDecisions.ContactEmailAddress, id = SettingsInDecisions.ContactEmailAddress, username = SettingsInDecisions.ContactEmailAddress
};
var jdataserver = new Rollbar.Classes.Server()
{
code_version = DecisionsVersion.CODE_VERSION.ToString(), cpu = GetCPUManufacturer(), host = GetComputerName(), ram = GetPhysicalMemory()
};
var jdatarequest = new Rollbar.Classes.Request()
{
user_ip = GetIPAddress()
};
var jdatatosend = new Rollbar.Classes.Data()
{
body = jdatabody,
code_version = DecisionsVersion.CODE_VERSION.ToString(),
environment = SettingsInDecisions.environment,
level = LogMessage.Level.ToString(),
person = jdataperson,
request = jdatarequest,
server = jdataserver
};
return(new Classes.JsonRollbarRootObject()
{
access_token = settings.PostServerItemID, data = jdatatosend
});
}
public void Should_Be_Able_to_Add_data_With_Key()
{
LogData data = new LogData(new StreamWriter(new MemoryStream()));
data.AddData("1", Encoding.UTF8.GetBytes("Hello World"));
}
protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
switch (logEvent)
{
case LogEvent.Error:
_log.LogError(message);
break;
case LogEvent.Warning:
_log.LogWarning(message);
break;
case LogEvent.Info:
_log.LogMessage(MessageImportance.Normal, message);
break;
case LogEvent.Debug:
_log.LogMessage(MessageImportance.Low, message);
break;
default:
break;
}
}
public LogzLogData(LogData source, string basePortalUrlName, string hostName)
{
this.source = source;
this.basePortalUrlName = basePortalUrlName;
this.hostName = hostName;
}
protected QueuedUpload(LogData logData)
{
LogData = logData ?? throw new ArgumentNullException(nameof(logData));
}
protected override bool ShouldIgnoreLogMessage(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
return(message.StartsWith("Uninitialized"));
}
public void GetWeatheMasterData(int i, string dataset, string url)
{
var jsonData = APIResponse.Content.ReadAsStringAsync().Result;
IManageLog manageLog = new ManageLog();
// TODO deserialize json into generic collection
List <dynamic> data = new List <dynamic>();
var finaldata = (JObject)JsonConvert.DeserializeObject(jsonData);
switch (i)
{
case 1:
var weatherDatasetTypesResult = finaldata["results"].Select(item => new
WeatherDatasetTypes
{
uid = item["uid"].ToString(),
mindate = Convert.ToDateTime(item["mindate"]),
maxdate = Convert.ToDateTime(item["maxdate"]),
name = item["name"].ToString(),
datacoverage = item["datacoverage"].ToString(),
id = item["id"].ToString(),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherDatasetTypesResult)
{
db.uspInsertWeatherDatasetTypesData(item.uid, item.mindate, item.maxdate, item.name, item.datacoverage, item.id);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
Console.WriteLine("Datset Updated");
Console.ReadLine();
break;
case 2:
var weatherDataCategoriesResult = finaldata["results"].Select(item => new
WeatherDataCategories
{
id = item["id"].ToString(),
name = item["name"].ToString(),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherDataCategoriesResult)
{
db.uspInsertWeatherDataCategoriesData(item.id, item.name);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
break;
case 3:
var weatherDataTypesResult = finaldata["results"].Select(item => new
WeatherDataTypes
{
mindate = Convert.ToDateTime(item["mindate"]),
maxdate = Convert.ToDateTime(item["maxdate"]),
name = item["name"].ToString(),
datacoverage = Convert.ToDecimal(item["datacoverage"]),
id = item["id"].ToString(),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherDataTypesResult)
{
db.uspInsertWeatherDataTypesData(item.mindate, item.maxdate, item.name, item.datacoverage, item.id);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
break;
case 4:
var weatherLocationCategoriesResult = finaldata["results"].Select(item => new
WeatherLocationCategories
{
id = item["id"].ToString(),
name = item["name"].ToString(),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherLocationCategoriesResult)
{
db.uspInsertWeatherLocationCategoriesData(item.id, item.name);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
break;
case 5:
var weatherLocationsResult = finaldata["results"].Select(item => new
WeatherLocations
{
mindate = Convert.ToDateTime(item["mindate"]),
maxdate = Convert.ToDateTime(item["maxdate"]),
name = item["name"].ToString(),
datacoverage = Convert.ToDecimal(item["datacoverage"]),
id = item["id"].ToString(),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherLocationsResult)
{
db.uspInsertWeatherLocationsData(item.mindate, item.maxdate, item.name, item.datacoverage, item.id);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
break;
case 6:
var weatherStationsResult = finaldata["results"].Select(item => new
WeatherStations
{
elevation = item["elevation"] != null ? Convert.ToDecimal(item["elevation"]) : 0,
mindate = Convert.ToDateTime(item["mindate"]),
maxdate = Convert.ToDateTime(item["maxdate"]),
latitude = Convert.ToDecimal(item["latitude"]),
name = item["name"].ToString(),
datacoverage = Convert.ToDecimal(item["datacoverage"]),
id = item["id"].ToString(),
elevationUnit = Convert.ToString(item["elevationUnit"]),
longitude = Convert.ToDecimal(item["longitude"]),
}).ToList();
using (var db = new DataLakeEntities())
{
foreach (var item in weatherStationsResult)
{
db.uspInsertWeatherStationsData(item.elevation, item.mindate, item.maxdate, item.latitude, item.name, item.datacoverage, item.id, item.elevationUnit, item.longitude);
}
LogData logdata = new LogData();
logdata.DatasetName = dataset;
logdata.DatasetURL = url;
manageLog.AddLog(logdata, true, "Ok");
}
break;
}
//dynamic d = JObject.Parse(jsonData);
// WeatherDatasets account = JsonConvert.DeserializeObject<WeatherDatasets>(jsonData);
//dynamic obj = finaldata["results"];
// return obj;
//data = (JObject)JsonConvert.DeserializeObject <dynamic>(jsonData);
// Iterating each element in generic collection
// Pass each entry to queue or topic
}
public void CheckExpectedResult()
{
this.treeName = "tVTestCases";
#region Variable Declarations
WinComboBox uICBConversationsComboBox = this.UIONVIFClientTestToolWindow.UICBConversationsWindow.UICBConversationsComboBox;
WinEdit uITBOutputEdit = this.UIONVIFClientTestToolWindow.UITBOutputWindow.UITBOutputEdit;
WinTree uITVTestCasesTree = this.UIONVIFClientTestToolWindow.UITVTestCasesWindow.UITVTestCasesTree;
WinTabPage uITestDetailsTabPage = this.UIONVIFClientTestToolWindow.UITCLogWindow.UITestDetailsTabPage;
WinList uILVStepsList = this.UIONVIFClientTestToolWindow.UILVStepsWindow.UILVStepsList;
#endregion
if (test.expectedResults != null)
{
// Щелкните "Test Details" вкладка
uITestDetailsTabPage.WaitForControlReady();
Mouse.Click(uITestDetailsTabPage);
foreach (DeviceExpectedResult device in test.expectedResults)
{
this.mac = device.deviceMAC;
foreach (ExpectedResult result in device.expectedResults)
{
foreach (string s in result.expectedResult.Keys)
{
mTree0 = result.parentNode0;
mTree1 = result.parentNode1;
mTree2 = s;
this.mTreeItem = this.UIONVIFClientTestToolWindow.UITVTestCasesWindow.UIProfileSTestCasesTreeItem.UIMediaProfileConfigurTreeItem.UIMEDIAPROFILECONFIGURTreeItem1;
bool currentResultNotStarted = false;
// Щелкните по элементу дерева
this.mTreeItem.WaitForControlExist();
Mouse.Click(this.mTreeItem);
LogData logData = new LogData();
if (uICBConversationsComboBox.Items.Count != 0)
{
// выбрать элемент в списке устройств
uICBConversationsComboBox.SelectedItem = this.macAndDevice["deviceName"] + " - " + this.macAndDevice[this.mac];
foreach (WinListItem item in uILVStepsList.Items)
{
TestStep testStep = new TestStep();
testStep.results = item.AccessibleDescription;
logData.testSteps.Add(testStep);
}
}
else
{
currentResultNotStarted = true;
}
if (currentResultNotStarted)
{
logData.currentResult = s + " NOT STARTED";
}
else
{
if (logData.testSteps.Count == 0)
{
logData.currentResult = s + " NOT DETECTED";
}
else
{
if (logData.testSteps.FindAll(C => C.results.Contains("NOT DETECTED")).Count != 0)
{
logData.currentResult = s + " NOT DETECTED";
}
else
{
if (logData.testSteps.FindAll(C => C.results.Contains("FAILED")).Count != 0)
{
logData.currentResult = s + " FAILED";
}
else
{
logData.currentResult = s + " PASSED";
}
}
}
}
logData.expectedResult = s + " " + result.expectedResult[s];
if (logData.currentResult == logData.expectedResult)
{
logData.result = "PASSED";
}
else
{
logData.result = "FAILED";
}
logData.testPath = this.testPath;
logData.deviceMAC = this.mac;
this.logData.Add(logData);
}
}
}
}
}
public void Save()
{
List <JHSemesterScoreRecord> addSemsScore = new List <JHSemesterScoreRecord>();
List <JHSemesterScoreRecord> updateSemsScore = new List <JHSemesterScoreRecord>();
SubjectScoreLogFormater subjLogFormater = new SubjectScoreLogFormater();
DomainScoreLogFormater domainLogFormater = new DomainScoreLogFormater();
foreach (StudentScore student in Students)
{
#region 決定要新增還是更新。
JHSemesterScoreRecord JHScore = GetJHSemesterScore(student.Id, student.SemestersScore[SemesterData.Empty]);
SCSemsScore SCScore = student.SemestersScore[SemesterData.Empty];
if (string.IsNullOrEmpty(JHScore.ID))
{
addSemsScore.Add(JHScore);
}
else
{
updateSemsScore.Add(JHScore);
}
#endregion
#region 產生科目資料。
JHScore.Subjects.Clear();
foreach (string strSubject in SCScore.Subject)
{
SemesterSubjectScore objSCSubject = SCScore.Subject[strSubject];
SubjectScore objJHSubject = GetJHSubjectScore(strSubject, objSCSubject);
LogData subjLog = new LogData(strSubject);
subjLog.Formater = subjLogFormater;
decimal?score = objSCSubject.Value.HasValue ? (decimal?)(double)objSCSubject.Value : null;
decimal?scoreOrigin = objSCSubject.ScoreOrigin.HasValue ? (decimal?)(double)objSCSubject.ScoreOrigin : null;
decimal?scoreMakeup = objSCSubject.ScoreMakeup.HasValue ? (decimal?)(double)objSCSubject.ScoreMakeup : null;
//記錄 Log
subjLog.Add(new LogData("成績", objJHSubject.Score + "", score.ToString()));
subjLog.Add(new LogData("原始成績", objJHSubject.ScoreOrigin + "", scoreOrigin.ToString()));
subjLog.Add(new LogData("補考成績", objJHSubject.ScoreMakeup + "", scoreMakeup.ToString()));
subjLog.Add(new LogData("權重", objJHSubject.Credit + "", objSCSubject.Weight + ""));
subjLog.Add(new LogData("節數", objJHSubject.Period + "", objSCSubject.Period + ""));
if (Program.Mode == ModuleMode.KaoHsiung)
{
subjLog.Add(new LogData("努力程度", objJHSubject.Effort + "", objSCSubject.Effort + ""));
}
subjLog.Add(new LogData("文字評量", objJHSubject.Text + "", objSCSubject.Text));
subjLog.Add(new LogData("領域", objJHSubject.Domain + "", objSCSubject.Domain));
SCScore.Subject.Log.Add(subjLog);
objJHSubject.Score = score;
objJHSubject.ScoreOrigin = scoreOrigin;
objJHSubject.ScoreMakeup = scoreMakeup;
objJHSubject.Credit = objSCSubject.Weight;
objJHSubject.Period = objSCSubject.Period;
objJHSubject.Effort = objSCSubject.Effort;
objJHSubject.Text = objSCSubject.Text;
objJHSubject.Domain = objSCSubject.Domain;
JHScore.Subjects.Add(strSubject, objJHSubject);
}
//排序科目名稱。
Dictionary <string, SubjectScore> orderSubject = new Dictionary <string, SubjectScore>(JHScore.Subjects);
JHScore.Subjects.Clear();
foreach (string subjName in Util.SortSubjectDomain(orderSubject.Keys))
{
JHScore.Subjects.Add(subjName, orderSubject[subjName]);
}
#endregion
#region 產生領域資料。
JHScore.Domains.Clear();
foreach (string strDomain in SCScore.Domain)
{
//彈性課程不記錄領域領域。
if (Util.IsVariableDomain(strDomain))
{
continue;
}
SemesterDomainScore objSCDomain = SCScore.Domain[strDomain];
DomainScore objJHDomain = GetJHDomainScore(strDomain, objSCDomain);
LogData domainLog = new LogData(strDomain);
domainLog.Formater = subjLogFormater;
decimal?score = objSCDomain.Value.HasValue ? (decimal?)(double)objSCDomain.Value : null;
decimal?scoreOrigin = objSCDomain.ScoreOrigin.HasValue ? (decimal?)(double)objSCDomain.ScoreOrigin : null;
decimal?scoreMakeup = objSCDomain.ScoreMakeup.HasValue ? (decimal?)(double)objSCDomain.ScoreMakeup : null;
//記錄 Log
domainLog.Add(new LogData("成績", objJHDomain.Score + "", score + ""));
domainLog.Add(new LogData("原始成績", objJHDomain.ScoreOrigin + "", scoreOrigin + ""));
domainLog.Add(new LogData("補考成績", objJHDomain.ScoreMakeup + "", scoreMakeup + ""));
domainLog.Add(new LogData("權重", objJHDomain.Credit + "", objSCDomain.Weight + ""));
domainLog.Add(new LogData("節數", objJHDomain.Period + "", objSCDomain.Period + ""));
if (Program.Mode == ModuleMode.KaoHsiung)
{
domainLog.Add(new LogData("努力程度", objJHDomain.Effort + "", objSCDomain.Effort + ""));
}
domainLog.Add(new LogData("文字評量", objJHDomain.Text + "", objSCDomain.Text));
SCScore.Domain.Log.Add(domainLog);
objJHDomain.Score = score;
objJHDomain.ScoreOrigin = scoreOrigin;
objJHDomain.ScoreMakeup = scoreMakeup;
objJHDomain.Credit = objSCDomain.Weight;
objJHDomain.Period = objSCDomain.Period;
objJHDomain.Effort = objSCDomain.Effort;
objJHDomain.Text = objSCDomain.Text;
JHScore.Domains.Add(strDomain, objJHDomain);
}
//記錄 Log
SCScore.LearningLog.Formater = domainLogFormater;
SCScore.LearningLog.OriginValue = JHScore.CourseLearnScore + "";
SCScore.LearningLog.NewValue = SCScore.LearnDomainScore + "";
SCScore.CourseLog.Formater = domainLogFormater;
SCScore.CourseLog.OriginValue = JHScore.CourseLearnScore + "";
SCScore.CourseLog.NewValue = SCScore.CourseLearnScore + "";
SCScore.LearningOriginLog.Formater = domainLogFormater;
SCScore.LearningOriginLog.OriginValue = JHScore.CourseLearnScoreOrigin + "";
SCScore.LearningOriginLog.NewValue = SCScore.LearnDomainScoreOrigin + "";
SCScore.CourseOriginLog.Formater = domainLogFormater;
SCScore.CourseOriginLog.OriginValue = JHScore.CourseLearnScoreOrigin + "";
SCScore.CourseOriginLog.NewValue = SCScore.CourseLearnScoreOrigin + "";
JHScore.LearnDomainScore = SCScore.LearnDomainScore;
JHScore.CourseLearnScore = SCScore.CourseLearnScore;
JHScore.LearnDomainScoreOrigin = SCScore.LearnDomainScoreOrigin;
JHScore.CourseLearnScoreOrigin = SCScore.CourseLearnScoreOrigin;
//排序領域名稱。
Dictionary <string, DomainScore> orderDomain = new Dictionary <string, DomainScore>(JHScore.Domains);
JHScore.Domains.Clear();
foreach (string domainName in Util.SortSubjectDomain(orderDomain.Keys))
{
JHScore.Domains.Add(domainName, orderDomain[domainName]);
}
#endregion
}
#region 新增科目成績
FunctionSpliter <JHSemesterScoreRecord, JHSemesterScoreRecord> addSpliter =
new FunctionSpliter <JHSemesterScoreRecord, JHSemesterScoreRecord>(500, 5);
addSpliter.Function = delegate(List <JHSemesterScoreRecord> part)
{
// 加入檢查當科目與領域成績筆數0不新增
List <JHSemesterScoreRecord> insertPart = new List <JHSemesterScoreRecord>();
foreach (JHSemesterScoreRecord rec in part)
{
// 沒有任何領域或科目成績
if (rec.Domains.Count == 0 && rec.Subjects.Count == 0)
{
continue;
}
insertPart.Add(rec);
}
if (insertPart.Count > 0)
{
JHSemesterScore.Insert(insertPart);
}
return(new List <JHSemesterScoreRecord>());
};
addSpliter.ProgressChange = delegate(int progress)
{
Reporter.Feedback("新增科目成績...", Util.CalculatePercentage(addSemsScore.Count, progress));
};
addSpliter.Execute(addSemsScore);
#endregion
#region 更新科目成績
FunctionSpliter <JHSemesterScoreRecord, JHSemesterScoreRecord> updateSpliter =
new FunctionSpliter <JHSemesterScoreRecord, JHSemesterScoreRecord>(500, 5);
updateSpliter.Function = delegate(List <JHSemesterScoreRecord> part)
{
JHSemesterScore.Update(part);
return(new List <JHSemesterScoreRecord>());
};
updateSpliter.ProgressChange = delegate(int progress)
{
Reporter.Feedback("更新科目成績...", Util.CalculatePercentage(updateSemsScore.Count, progress));
};
updateSpliter.Execute(updateSemsScore);
#endregion
}
internal Gate(Self owner, LogData logData)
{
this.owner = owner; this.logData = logData;
}
public Task <DpsReportResponse> UploadLogAsync(LogData log, string userToken = null)
{
return(UploadLogAsync(log, CancellationToken.None, userToken));
}
public void AddUserData(LogData log)
{
firebase.Child("logs/").PostAsync <LogData>(log);
}
public void WriteLog(LogData logData)
{
Console.WriteLine(logData);
}
public void Awake()
{
LogData.instance = this;
}
/// <summary>
/// Returns whether the log message should be ignored
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The extra data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
/// <returns><c>true</c> if the message should be ignored, <c>false</c> otherwise.</returns>
protected virtual bool ShouldIgnoreLogMessage(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
// Should be removed in v6
if (ShouldIgnoreLogMessage(log, message, logEvent, extraData, time))
{
return true;
}
return false;
}
public async Task UpdateLogDataAsync(LogData logData, bool sync = false)
{
await _itemManagerWrapper.SaveTaskAsync(logData, sync);
}
/// <summary>
/// Formats the log event to a message which can be written to a log persistence storage.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="extraData">The extra data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
/// <returns>The formatted log event.</returns>
protected virtual string FormatLogEvent(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
{
var logMessage = string.Format("{0} => [{1}] [{2}] [{3}] {4}", time.ToString(_timeFormat), LogEventStrings[logEvent], log.TargetType.FullName, ThreadHelper.GetCurrentThreadId(), message);
return logMessage;
}
private void AddLog(LogData log)
{
Work.Log.Add(log);
}
/// <summary>
/// Called when a <see cref="LogEvent.Status" /> message is written to the log.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="message">The message.</param>
/// <param name="extraData">The additional data.</param>
/// <param name="logData">The log data.</param>
/// <param name="time">The time.</param>
protected virtual void Status(ILog log, string message, object extraData, LogData logData, DateTime time)
{
// Empty by default
}
private void dgLog_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
DataGrid dg = sender as DataGrid;
Point pt = e.GetPosition(dg);
DataGridCell dgcell = null;
VisualTreeHelper.HitTest(dg, null, (result) => {
DataGridCell cell = FindVisualParent <DataGridCell>(result.VisualHit);
if (cell != null)
{
dgcell = cell;
return(HitTestResultBehavior.Stop);
}
else
{
return(HitTestResultBehavior.Continue);
}
}, new PointHitTestParameters(pt));
if (dgcell == null)
{
return;
}
LogData ld = dgcell.DataContext as LogData;
ContextMenu cm = new ContextMenu();
var datalist = new ObservableCollection <LogData>(dg.SelectedItems.Cast <LogData>().ToList <LogData>());
if (!datalist.Contains(ld))
{
dg.SelectedItem = ld;
}
MenuItem mi = new MenuItem();
mi.Click += SearchByWeb;
mi.Header = "Webで検索(" + ld.Callsign + ")";
mi.CommandParameter = Callsign.GetRemovedStroke(ld.Callsign);
cm.Items.Add(mi);
MenuItem miLogEdit = new MenuItem();
miLogEdit.Click += EditLog;
miLogEdit.Header = "ログ修正";
MenuItem miLogSearch = new MenuItem();
miLogSearch.Click += SearchLogEachly;
miLogSearch.Header = "集計処理";
if (!datalist.Contains(ld) || datalist.Count == 1)
{
cm.Items.Add(new Separator());
miLogEdit.CommandParameter = new ObservableCollection <LogData>()
{
ld
};
miLogSearch.CommandParameter = new ObservableCollection <LogData>()
{
ld
};
}
else
{
MenuItem miSearches = new MenuItem();
miSearches.Click += SearchByWeb;
miSearches.Header = "Webで検索(" + datalist.Count + "件)";
miSearches.CommandParameter = datalist;
cm.Items.Add(miSearches);
cm.Items.Add(new Separator());
miLogEdit.CommandParameter = datalist;
miLogSearch.CommandParameter = datalist;
}
cm.Items.Add(miLogEdit);
cm.Items.Add(miLogSearch);
ContextMenuService.SetContextMenu(dgcell, cm);
}
