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); }