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);
internal static async Task LogMessageAsync(string message, MessageCategory category = MessageCategory.Information, string details = null)
{
await BuildWorkerApi.AddMessageAsync(message, category, details);
}
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);
}
