public Task WriteAsync(MessageCategory category, string message) { EnsurePaneVisible(); _pane.OutputStringThreadSafe(message); return Task.CompletedTask; }
public static ExecutionResult Merge(this ExecutionResult executionResult, IEnumerable<ValidationFailure> validationFailures, MessageCategory withMessageCategory = MessageCategory.BrokenBusinessRule) { if (executionResult != null) { validationFailures.Each( x => executionResult.Add(MessageCategory.BrokenBusinessRule, x.ErrorMessage, x.PropertyName)); } return executionResult; }
private string GetStringToWrite(MessageCategory category, string message) { var categoryString = GetCategoryString(category); var prefix = Invariant($"[{DateTime.Now:yy-M-dd_HH-mm-ss}]{categoryString}:"); if (!message.Take(message.Length - 1).Contains('\n')) { return prefix + message; } var emptyPrefix = new string(' ', prefix.Length); var lines = message.Split(_lineBreaks, StringSplitOptions.RemoveEmptyEntries) .Select((line, i) => i == 0 ? prefix + line + "\n" : emptyPrefix + line + "\n"); return string.Concat(lines); }
/// <summary> /// Merge all error found in a validation dictionary to the current application message /// </summary> /// <param name="executionResult">instance of IApplicationMessage</param> /// <param name="validationDictionary">instance of IValidationDictionary</param> /// <param name="againstMessageCategory">add error message into this category</param> /// <returns>instance of application message in order to chain to other operations</returns> public static ExecutionResult Merge(this ExecutionResult executionResult, IValidationDictionary validationDictionary, MessageCategory againstMessageCategory = MessageCategory.BrokenBusinessRule) { if (executionResult == null) return null; if (validationDictionary != null) { validationDictionary .Each(item => executionResult.Add(againstMessageCategory, new MessageGroup(item.Value.ToList()))); } return executionResult; }
/// <summary> /// Merge all error found in an application message into the current validation dictionary /// </summary> /// <param name="validationDictionary">instance of IValidationDictionary</param> /// <param name="executionResult">instance of IApplicationMessage</param> /// <param name="fromMessageCategory">look for error messages from this category</param> /// <returns></returns> public static IValidationDictionary Merge(this IValidationDictionary validationDictionary, ExecutionResult executionResult, MessageCategory fromMessageCategory = MessageCategory.BrokenBusinessRule) { if ((validationDictionary != null) && (executionResult != null) && !executionResult.IsSuccessFull) { var propertyName = executionResult[fromMessageCategory].PropertyName; executionResult[fromMessageCategory] .Messages .Each(errorMessage => validationDictionary.AddError(propertyName, errorMessage)); } return validationDictionary; }
public static ExecutionResult Merge(this ExecutionResult executionResult, IEnumerable<ValidationFailure> validationFailures, MessageCategory withMessageCategory = MessageCategory.BrokenBusinessRule) { if (executionResult != null) { foreach (var validationFailure in validationFailures) { executionResult.Add(MessageCategory.BrokenBusinessRule, validationFailure.ErrorMessage, validationFailure.PropertyName); } } return executionResult; }
protected string FormatMessage(string message, MessageCategory category) { return(String.Format("{0}: {1}", category, message)); }
public BaseMessage(string payload, MessageCategory category) { Payload = payload; EventTime = DateTime.UtcNow; Category = category; }
/// <summary> /// Add a list of message description for a message category /// </summary> /// <param name="messageCategory">type of message which can fall into 4 categories (informative, warning, broken bussiness rule and fatal system exception</param> /// <param name="messageGroup">List of messages to be added to this message type</param> public void Add(MessageCategory messageCategory, MessageGroup messageGroup) { if ((messageGroup == null) || (!messageGroup.Messages.Any())) { messageCategory = MessageCategory.FatalException; String message; if (messageGroup == null) { message = "No message description has been specified"; messageGroup = new MessageGroup(); } else { message = messageGroup.Messages.Any(String.IsNullOrWhiteSpace) ? "All message description must be specified" : "No message type has been specified"; } messageGroup.Messages.Add(message); } if (_messages.ContainsKey(messageCategory)) { foreach (var m in messageGroup.Messages) { if (!_messages[messageCategory].Messages.Contains(m)) { _messages[messageCategory].Messages.Add(m); } } } else { _messages.Add(messageCategory, messageGroup.Clone()); } }
public void Write(MessageCategory category, string message) { EnsurePaneVisible(); _pane?.OutputStringThreadSafe(message); }
public Task WriteFormatAsync(MessageCategory category, string format, params object[] arguments) { return Task.CompletedTask; }
public Secure3dBuilder WithMessageCategory(MessageCategory value) { MessageCategory = value; return(this); }
public void WriteFormat(LogVerbosity verbosity, MessageCategory category, string format, params object[] arguments) => _log.WriteFormat(verbosity, category, format, arguments);
public Task WriteLineAsync(MessageCategory category, string message) { return Task.CompletedTask; }
public void PutMessage(MessageCategory cat, string msg) { var upTime = messagePublished.ReceiveValue(cat); if (upTime.HasValue) { var deltaSec = (DateTime.Now - upTime.Value).TotalSeconds; if (deltaSec < minSecondsBetweenSameMessages) return; } messages.Add(new Cortege2<MessageCategory, string>(cat, msg), 1000); messagePublished.UpdateValues(cat, DateTime.Now); }
/// <summary> /// Get a message group for a specific message type /// </summary> /// <param name="messageCategory"></param> /// <returns></returns> public MessageGroup GetMessageGroup(MessageCategory messageCategory) { if (IsEmpty || !Contains(messageCategory)) return new MessageGroup(new List<string>(), messageCategory.ToTitle()); return _messages[messageCategory]; }
/// <summary> /// Remove all message for a message type /// </summary> /// <param name="messageCategory"></param> public void Remove(MessageCategory messageCategory) { if (_messages.ContainsKey(messageCategory)) { _messages.Remove(messageCategory); } }
/// <summary> /// Get all the messages for specific message type /// </summary> /// <param name="messageCategory"></param> /// <returns></returns> public IEnumerable<String> GetMessages(MessageCategory messageCategory) { var messageGroup = GetMessageGroup(messageCategory); return messageGroup != null ? messageGroup.Messages : new List<String>(); }
/// <summary> /// Checks if a message type exists /// </summary> /// <param name="messageCategory">type of message which can fall into 4 categories (informative, warning, broken bussiness rule and fatal system exception</param> /// <returns>Boolean</returns> public Boolean Contains(MessageCategory messageCategory) { return _messages.ContainsKey(messageCategory); }
/// <summary> /// Add a new message description into a message category /// </summary> /// <param name="messageCategory">type of message which can fall into 4 categories (informative, warning, broken bussiness rule and fatal system exception</param> /// <param name="message"> /// User friendly message that gives a clear description of what the message type means /// More than one message can be added to the same message category /// </param> public void Add(MessageCategory messageCategory, String message, String[] propertyNames = null) { Add(messageCategory, new MessageGroup(new List<String> { message }, propertyNames)); }
/// <summary> /// 插入系统信息 /// </summary> /// <param name="title"></param> /// <param name="content"></param> /// <param name="recieveId"></param> /// <param name="sourceId"></param> /// <param name="sourceType"></param> /// <param name="moduleKey"></param> /// <param name="category"></param> /// <returns></returns> private bool InsertSystemMessage(string title, string content, string recieveId, Guid?sourceId, string sourceType, string moduleKey, MessageCategory category = MessageCategory.System) { using (var dbContext = new SystemMessageDbContext()) { var systemMessage = new Models.SystemMessage { Id = KeyGenerator.GetGuidKey(), Title = title, Content = content, SourceId = sourceId, MessageType = recieveId == null ? MessageType.Public : MessageType.Personal, CreateTime = DateTime.Now, SourceType = sourceType, ModuleKey = moduleKey, Category = category }; dbContext.SystemMessages.Add(systemMessage); if (recieveId != null) { var systemMessageReciever = new SystemMessageReciever { Id = KeyGenerator.GetGuidKey(), MessageId = systemMessage.Id, RecieveId = recieveId, CreateTime = DateTime.Now, Status = Status.UnRead }; dbContext.SystemMessageRecievers.Add(systemMessageReciever); } var result = dbContext.SaveChanges(); return(result > 0); } }
public MessageTypeDetailsAttribute(MessageDirection direction, MessageCategory category, int protocolVersion) { mDirection = direction; mCategory = category; mProtocolVersion = protocolVersion; }
/// <summary> /// 发送推送消息 /// </summary> /// <param name="title"></param> /// <param name="content"></param> /// <param name="pushContent"></param> /// <param name="recieveId"></param> /// <param name="sourceId"></param> /// <param name="pushParas"></param> /// <param name="sourceType"></param> /// <param name="moduleKey"></param> /// <param name="category"></param> /// <returns></returns> public bool CreatePushSystemMessage(string title, string content, string pushContent, string recieveId, Guid?sourceId, Dictionary <string, string> pushParas = null, string sourceType = "", string moduleKey = "", MessageCategory category = MessageCategory.System) { try { var success = InsertSystemMessage(title, content, recieveId, sourceId, sourceType, moduleKey, category); if (success) { if (string.IsNullOrWhiteSpace(pushContent)) { pushContent = "你有一条新消息"; } if (recieveId == null) { _pushService.Push(pushContent, pushParas); } else { _pushService.Push(pushContent, recieveId.ToString(), pushParas); } } return(success); } catch (Exception ex) { Logger.Error(ex, "发送消息失败"); return(false); } }
public void AddMessage(MessageCategory category, MessagePriority priority, int secondsDuration, string text) { var message = new Message(); message.CreatedAt = BestTime; message.Text = text; message.Priority = priority; message.Duration = new TimeSpan(0,0,0,secondsDuration); AddMessage(message); }
private static async Task RetrySendVideo(FileInfo file, int k, TimeSpan duration, MessageCategory messageCategory) { try { Bot = new TelegramBotClient(ApiToken); var me = Bot.GetMeAsync().Result; Bot.StartReceiving(); Thread.Sleep(5000); var retryStream = File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read); var inputFile = new InputOnlineFile(retryStream); inputFile.FileName = file.FullName.Split('\\').Last(); var title = inputFile.FileName + Environment.NewLine + "#" + messageCategory; title += Environment.NewLine + "#" + messageCategory + "No" + k; var result = await Bot.SendVideoAsync(ChatId, inputFile, duration : Convert.ToInt32(Math.Truncate(duration.TotalSeconds)), caption : inputFile.FileName); Utility.AppendToJsonFile(result, messageCategory); } catch (Exception ex) { Console.Write($"retry failed with message:{ex.Message}. retrying again ..."); await RetrySendVideo(file, k, duration, messageCategory); } }
/// <summary> /// Build a new application message with single message against a message type /// </summary> /// <param name="messageCategory">type of message which can fall into 4 categories (informative, warning, broken bussiness rule and fatal system exception</param> /// <param name="message"> /// User friendly message that gives a clear description of what the message type means /// More than one message can be added to the same message category /// </param> public ExecutionResult(MessageCategory messageCategory, String message) { Add(messageCategory, message, null); }
public async Task WriteFormatAsync(LogVerbosity verbosity, MessageCategory category, string format, params object[] arguments) { await EnsureCreatedAsync(); string message = string.Format(CultureInfo.InvariantCulture, format, arguments); await _logs[(int)verbosity].WriteAsync(category, message); }
public Task WriteFormatAsync(MessageCategory category, string format, params object[] arguments) { return(Task.CompletedTask); }
//-------------[ Delete Messages ]---------------------// public bool DeleteMessage(DoneDelegate callback, long fromUid, long toId, long messageId, MessageCategory messageCategory, int timeout = 0) { return(DeleteMessage(callback, fromUid, toId, messageId, (byte)messageCategory, timeout)); }
public Task WriteAsync(MessageCategory category, string message) { return _messages.SendAsync(GetStringToWrite(category, message)); }
public void WriteLine(LogVerbosity verbosity, MessageCategory category, string message) => _logs.Value[(int)verbosity].Write(category, message + Environment.NewLine);
/// <summary> /// Get a message group for a specific message type /// </summary> /// <param name="messageCategory">a message category</param> /// <returns>a collection of messages with a title</returns> public MessageGroup this[MessageCategory messageCategory] { get { return GetMessageGroup(messageCategory); } }
public Task WriteAsync(MessageCategory category, string message) { return(_messages.SendAsync(GetStringToWrite(category, message))); }
/// <summary> /// Build a new application message with a list of message description for a message category /// </summary> /// <param name="messageCategory">type of message which can fall into 4 categories (informative, warning, broken bussiness rule and fatal system exception</param> /// <param name="message">List of messages to be added to this message type</param> public ExecutionResult(MessageCategory messageCategory, MessageGroup messageGroup) { Add(messageCategory, messageGroup); }
private static string GetCategoryString(MessageCategory category) { switch (category) { case MessageCategory.Error: return "[ERROR]"; case MessageCategory.Warning: return "[WARNING]"; default: return string.Empty; } }
public Task WriteAsync(MessageCategory category, string message) { return(Task.CompletedTask); }
public Task WriteAsync(MessageCategory category, string message) { EnsurePaneVisible(); _pane?.OutputStringThreadSafe(message); return(Task.CompletedTask); }
public Task WriteAsync(MessageCategory category, string message) => Task.CompletedTask;
/// <summary> /// Add a category filter. /// </summary> /// <param name="loggerConfiguration"></param> /// <param name="category"></param> /// <param name="sink"></param> /// <returns></returns> public static LoggerConfiguration CategoryFilter(this LoggerSinkConfiguration loggerConfiguration, MessageCategory category, ILogEventSink sink) { return(loggerConfiguration.Sink(new CategoryFilterSink(category, sink))); }
//---------------------------------------------------------------------- // Constructors //---------------------------------------------------------------------- /// <summary> /// Contains the information for a TestServcies MessageEvent. /// </summary> /// <param name="category">The category of Message (Assert, Log, Trace). /// </param> /// <param name="message">The text of the message.</param> public MessageEventArgs(MessageCategory category, string message) { _category = category; _message = message; }
private static async Task RetrySendAudio(FileInfo file, int k, TimeSpan duration, MessageCategory messageCategory) { try { Bot = new TelegramBotClient(ApiToken); var me = Bot.GetMeAsync().Result; //Bot.StopReceiving(); Bot.StartReceiving(); Thread.Sleep(5000); var retryStream = System.IO.File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read); var fts = new FileToSend(); fts.Content = retryStream; fts.Filename = file.FullName.Split('\\').Last(); var title = fts.Filename + Environment.NewLine + "#" + messageCategory; title += Environment.NewLine + "#" + messageCategory + "No" + k; var result = await Bot.SendAudioAsync(ChatId, fts, Convert.ToInt32(Math.Truncate(duration.TotalSeconds)), fts.Filename, title); AppendToJsonFile(result, messageCategory); } catch (Exception ex) { Console.Write($"retry failed with message:{ex.Message}. retrying again ..."); await RetrySendAudio(file, k, duration, messageCategory); } }
public void WriteLine(MessageCategory category, string message) { Messages.Add(new TextMessage(category, message)); }
public virtual void Write(string message, MessageCategory category) { Write(FormatMessage(message, category)); }
public void WriteLine(MessageCategory category, MessageContent content) { Messages.Add(new TextMessage(category, content)); }
/// <summary> /// 创建新的系统消息 /// </summary> /// <param name="title"></param> /// <param name="content"></param> /// <param name="recieveId"></param> /// <param name="sourceId"></param> /// <param name="sourceType"></param> /// <param name="moduleKey"></param> /// <param name="category"></param> /// <returns></returns> public bool CreateSystemMessage(string title, string content, string recieveId, Guid?sourceId, string sourceType = "", string moduleKey = "", MessageCategory category = MessageCategory.System) { return(InsertSystemMessage(title, content, recieveId, sourceId, sourceType, moduleKey, category)); }
public CategoryFilterSink(MessageCategory categories, ILogEventSink sink) { Categories = categories; Sink = sink; }
public MessageTypeDetailsAttribute(MessageDirection direction, MessageCategory category, int protocolVersion) { Direction = direction; Category = category; mProtocolVersion = protocolVersion; }
internal static async Task LogMessageAsync(string message, MessageCategory category = MessageCategory.Information, string details = null) { await BuildWorkerApi.AddMessageAsync(message, category, details); }
public void Write(MessageCategory category, string message) { }
internal CommonFromLogger(ILogger logger, MessageCategory category) { _logger = logger; Category = category; }
public void Write(LogVerbosity verbosity, MessageCategory category, string message) => _log.Write(verbosity, category, message);
public GenericResult AddMessage(string text, MessageCategory messageCategory) { Messages.Add(new Message(text, messageCategory)); return this; }
ExtractEventInfo(LogEvent logEvent) { String activityId = String.Empty, methodName = String.Empty, classType = String.Empty, stacktrace = string.Empty, identity = string.Empty, /* Unmerged change from project 'Arc4u.Standard.Diagnostics.Serilog (netstandard2.1)' * Before: * application = string.Empty; * * int processId = -1, * After: * application = string.Empty; * * int processId = -1, */ application = string.Empty; int processId = -1, threadId = -1; short category = -1; var filteredProperties = new List <LogEventProperty>(); foreach (var property in logEvent.Properties) { switch (property.Key) { case LoggingConstants.ActivityId: activityId = GetValue(property.Value, Guid.Empty.ToString()); break; case LoggingConstants.MethodName: methodName = GetValue(property.Value, String.Empty); break; case LoggingConstants.Class: classType = GetValue(property.Value, String.Empty); break; case LoggingConstants.ProcessId: processId = GetValue(property.Value, -1); break; case LoggingConstants.ThreadId: threadId = GetValue(property.Value, -1); break; case LoggingConstants.Category: category = GetValue(property.Value, (short)1); break; case LoggingConstants.Stacktrace: stacktrace = GetValue(property.Value, String.Empty); break; case LoggingConstants.Identity: identity = GetValue(property.Value, String.Empty); break; case LoggingConstants.Application: application = GetValue(property.Value, String.Empty); break; case ExceptionDetail: break; default: if (property.Key != "State") { filteredProperties.Add(new LogEventProperty(property.Key, property.Value)); } break; } } MessageCategory _category = MessageCategory.Technical; if (Enum.IsDefined(typeof(MessageCategory), category)) { _category = (MessageCategory)Enum.ToObject(typeof(MessageCategory), category); } return(_category, application, identity, classType, methodName, activityId, processId, threadId, stacktrace, filteredProperties); }
public DispatchPartition(MessageCategory category, int min, int max) { this.Category = category; this.MinPartition = min; this.MaxPartition = max; }
public async Task WriteLineAsync(LogVerbosity verbosity, MessageCategory category, string message) { await EnsureCreatedAsync(); await _logs[(int)verbosity].WriteAsync(category, message + Environment.NewLine); }
public void Write(LogVerbosity verbosity, MessageCategory category, string message) => _logs.Value[(int)verbosity].Write(category, message);
public void WriteFormat(LogVerbosity verbosity, MessageCategory category, string format, params object[] arguments) { string message = string.Format(CultureInfo.InvariantCulture, format, arguments); _logs.Value[(int)verbosity].Write(category, message); }
public int DeleteMessage(long fromUid, long toId, long messageId, MessageCategory messageCategory, int timeout = 0) { return(DeleteMessage(fromUid, toId, messageId, (byte)messageCategory, timeout)); }
public AndConstraint<ExecutionResultAssertions> HaveErrorMessageOfType(MessageCategory messageCategory) { Execute.Verification .ForCondition(ExecutionResult.Errors.Any(e => e.Key == messageCategory)) .FailWith("Execution result expected to have an error message of type {0} but actually found {1}", messageCategory.Humanize(LetterCasing.Sentence), AllErrorMessageCategories); return new AndConstraint<ExecutionResultAssertions>(this); }