private void LogWriteEntry(object source, MessageRecievedEventArgs e)
{
EventLogEntryType msgType;
switch (e.Status)
{
case MessageTypeEnum.WARNING:
msgType = EventLogEntryType.Warning;
break;
case MessageTypeEnum.ERROR:
msgType = EventLogEntryType.Error;
break;
default:
msgType = EventLogEntryType.Information;
break;
}
eventLog1.WriteEntry(e.Message, msgType);
}
/// <summary>
/// eventLog1_EntryWritte function.
/// converts from MessageTypeEnum to EventLogEntryType and write to log.
/// </summary>
/// <param name="sender">sender obj</param>
/// <param name="e" >MessageRecievedEventArgs obj</param>
private void eventLog1_EntryWritten(object sender, MessageRecievedEventArgs e)
{
EventLogEntryType type;
switch (e.Status)
{
case MessageTypeEnum.WARNING:
type = EventLogEntryType.Warning;
break;
case MessageTypeEnum.FAIL:
type = EventLogEntryType.Error;
break;
case MessageTypeEnum.INFO:
default:
type = EventLogEntryType.Information;
break;
}
eventLog1.WriteEntry(e.Message, type);
}
/// <summary>
/// ivoked by event and wties to system log. specifically here by logger's event of messaging
/// </summary>
/// <param name="sender">sender</param>
/// <param name="args">arguments</param>
private void MessageRecievedOperation(object sender, MessageRecievedEventArgs args)
{
// get message type
EventLogEntryType messageType;
switch (args.Status)
{
case MessageTypeEnum.WARNING:
messageType = EventLogEntryType.Warning; break;
case MessageTypeEnum.INFO:
messageType = EventLogEntryType.Information; break;
case MessageTypeEnum.FAIL:
messageType = EventLogEntryType.Error; break;
default:
messageType = EventLogEntryType.Information; break;
}
eventLog1.WriteEntry(args.Message, messageType);
logCollectionSingleton.LogsCollection.Add(new LogItem(args.Status, args.Message));
}
/// <summary>
/// The function writes a log to the service's event log.
/// </summary>
/// <param name="sender">The object that sent the massage</param>
/// <param name="args">The massage argumnts.</param>
private void writeLog(object sender, MessageRecievedEventArgs args)
{
switch (args.Status)
{
case MessageTypeEnum.INFO: {
eventLog1.WriteEntry(args.Message, EventLogEntryType.Information);
break;
}
case MessageTypeEnum.FAIL:
{
eventLog1.WriteEntry(args.Message, EventLogEntryType.Error);
break;
}
case MessageTypeEnum.WARNING:
{
eventLog1.WriteEntry(args.Message, EventLogEntryType.Warning);
break;
}
}
}
/// <summary>
/// This method is being written to the MessageRecieved event and
/// write to the logger
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Logger_MessageRecieved(object sender, MessageRecievedEventArgs e)
{
EventLogEntryType msg = EventLogEntryType.Information; // default
// for error or warning msg
switch (e.Status)
{
case MessageTypeEnum.FAIL:
msg = EventLogEntryType.Error;
break;
case MessageTypeEnum.WARNING:
msg = EventLogEntryType.Warning;
break;
}
// add this log msg to the list of msgs
WriterMut.WaitOne();
LogService.Instance.addLogToList(e);
// write entry with the msg
eventLog.WriteEntry(e.Message, msg, eventId++);
WriterMut.ReleaseMutex();
}
/// <summary>
/// method to write to the event logger of the service
/// </summary>
/// <param name="sender">message sender</param>
/// <param name="messageArgs">info about the message sent</param>
private void WriteToEventLogger(object sender, MessageRecievedEventArgs messageArgs)
{
string messageOpenning = "";
switch (messageArgs.Status)
{
case MessageTypeEnum.FAIL:
messageOpenning += "FAILED: ";
break;
case MessageTypeEnum.INFO:
messageOpenning += "INFO: ";
break;
case MessageTypeEnum.WARNING:
messageOpenning += "WARNING: ";
break;
default:
messageOpenning += "UNKNOWN MESSAGE TYPE: ";
break;
}
this.eventLog1.WriteEntry(messageOpenning += messageArgs.Message);
}
/// <summary>
/// The class used by the event for logging.
/// </summary>
/// <param name="sender">the sender of the thing</param>
/// <param name="args">the evernt arguements</param>
private void C_MessageRecieved(object sender, MessageRecievedEventArgs args)
{
EventLogEntryType EventLogType;
switch (args.Status)
{
case MessageTypeEnum.FAIL:
EventLogType = EventLogEntryType.Error;
break;
case MessageTypeEnum.INFO:
EventLogType = EventLogEntryType.Information;
break;
case MessageTypeEnum.WARNING:
EventLogType = EventLogEntryType.Warning;
break;
default:
EventLogType = EventLogEntryType.Error;
break;
}
eventLog1.WriteEntry(args.Message, EventLogType);
}
public void sendLog(string msg, MessageTypeEnum status)
{
MessageRecievedEventArgs msg1 = new MessageRecievedEventArgs(status, msg);
string message;
/* if ((message = JsonConvert.SerializeObject(msg1)) == null)
* {
* Debug.WriteLine("Json not work");
* return;
* }*/
DataInfo cmdMsg =
new DataInfo(CommandEnum.newLogEntryCommand, JsonConvert.SerializeObject(msg1));
Debug.WriteLine("in sendlog!!");
/*List<MessageRecievedEventArgs> args = m_logging.getHistoryLog();
* string argsJson = JsonConvert.SerializeObject(args);
* DataInfo inf = new DataInfo(CommandEnum.LogCommand, argsJson);
* string infJson = JsonConvert.SerializeObject(inf);
* //this.m_logging.Log("in send log", MessageTypeEnum.INFO);
* this.tcpServer.sendMsgToAll(infJson);*/
//string infJson = JsonConvert.SerializeObject(cmdMsg);
this.tcpServer.sendMsgToAll(cmdMsg.toJson());
}
/// <summary>
/// Called when a messege is recieved.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="MessageRecievedEventArgs" /> instance containing the event data.</param>
private void OnMessegeRecieved(object sender, MessageRecievedEventArgs args)
{
eventLog.WriteEntry(args.Message, args.EventLogEntryType);
}
/// <summary>
/// writes the messages received to the log
/// </summary>
/// <param name="sender">the sender </param>
/// <param name="e">the arguments</param>
private void OnMsg(object sender, MessageRecievedEventArgs e)
{
eventLog1.WriteEntry(e.Message, GetType(e.Status));
}
/// <summary>writes to the log</summary>
/// <param name="sender"> sender object</param>
/// <param name="args" >function args</param>
public void WriteMessage(Object sender, MessageRecievedEventArgs args)
{
eventLog1.WriteEntry(args.Message, GetType(args.Status));
}
/// <summary>
/// Ons the MSG.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="MessageRecievedEventArgs"/> instance containing the event data.</param>
private void onMsg(object sender, MessageRecievedEventArgs e)
{
eventLog1.WriteEntry(e.Message);
}
public void Log(string message, MessageTypeEnum type)
{
MessageRecievedEventArgs msg = new MessageRecievedEventArgs(type, message);
MessageRecieved.Invoke(this, msg);
}
public void newLog(object sender, MessageRecievedEventArgs e)
{
this.history.Add(e);
}
public void OnMessage(object sender, MessageRecievedEventArgs e)
{
eventLog1.WriteEntry(e.Message);
}
/**
* update the log that msg recived.
*/
private void Logging_MessageRecieved(object sender, MessageRecievedEventArgs e)
{
eventLog1.WriteEntry(e.Status + ": " + e.Message);
}
/// <summary>
/// Write message to entry
/// </summary>
/// <param name="sender">The sender of the message</param>
/// <param name="m">The message args</param>
public void WriteToEntry(Object sender, MessageRecievedEventArgs m)
{
eventLog1.WriteEntry(m.Message, StatusConverter(m.Status));
}
/// <summary>
/// Getting a message to write to the logging
/// </summary>
/// <param name="sender"></param>
/// <param name="messageArgs"></param>
private void OnMessage(object sender, MessageRecievedEventArgs messageArgs)
{
string status = (messageArgs.Status as Enum).ToString() + ";";
eventLog1.WriteEntry(status + messageArgs.Message, EventLogEntryType.Information, eventId++);
}
/// <summary>
/// Write entry to event log. Specific message will be written.
/// </summary>
/// <param name="sender"> Sender object requesting write entry. </param>
/// <param name="message"> Message that will be written. </param>
public void OnMsg(object sender, MessageRecievedEventArgs message)
{
eventLogger.WriteEntry(message.Message, ConvertStatToEventLogEntry(message.Status));
}
public void printMsg(Object sender, MessageRecievedEventArgs e)
{
eventLog1.WriteEntry(GetType(e.Status).ToString() + ";" + e.Message);
}
public void onMsg(object sender, MessageRecievedEventArgs msgArgs)
{
this.writeToEventLogger(msgArgs.Message);
}
/// <summary>
/// The method logs the given message to the EventLogger.
/// </summary>
/// <param name="sender"></param> The object the invoked the event that this method was registered to.
/// <param name="args"></param> THe args for the event invoked.
private void onMessageReceived(object sender, MessageRecievedEventArgs args)
{
eventLog1.WriteEntry(args.Message, logger.GetMessageType(args.Status));
}
/// <summary>
/// happens when there is a new connection in the server.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void newConnectionHandler(object sender, MessageRecievedEventArgs e)
{
logging.Log("start a new connection", MessageTypeEnum.INFO);
}
public void updateServer(object Sender, MessageRecievedEventArgs args)
{
this.GotCommand.Invoke(Sender, args);
}
/// <summary>
/// Handling the close of the server
/// </summary>
/// <param name="sender"> the handler most likely</param>
/// <param name="args"> arguments</param>
///
public void getCommand(object sender, MessageRecievedEventArgs eventArgs)
{
// TBD interpret command, and if handler to be closed, close it and inform gui
}
public void writeMessage(Object sender, MessageRecievedEventArgs e)
{
eventLog.WriteEntry(e.Message, GetType(e.Status));
}
/// <summary>
/// Write the input message to the eventlog.
/// </summary>
/// <param name="sender">Raising object</param>
/// <param name="eventArgs">Event args</param>
private void writeMessage(object sender, MessageRecievedEventArgs eventArgs)
{
// Write to the event log:
_eventLog.WriteEntry(eventArgs.Message);
}
private void SendLogToClients(object sender, MessageRecievedEventArgs e)
{
Log log = new Log((int)e.Status, e.Message);
// tcpServer.SendToAllClients((int)SendClientEnum.AddLog, log.ToJSON());
}
/// <summary>
/// The Function is passing the given message using the event log
/// </summary>
/// <param name="sender">The sender of the message</param>
/// <param name="e">The arguments of the message</param>
void Logging_MessageRecieved(object sender, MessageRecievedEventArgs e)
{
eventLog.WriteEntry(e.Message, (EventLogEntryType)e.Status);
}
