private void CheckMessageConfirmedBy(IMessageModel confirmation)
{
if (confirmation is null)
{
throw new ArgumentNullException(nameof(confirmation));
}
IMessageModel message;
lock (_getNextMessageLock)
message = GetMessageConfirmedBy(confirmation);
using (_currentlyProcessingIdLock.Write())
_currentlyProcessingId = message is null ? string.Empty : message.Id;
if (message is null)
{
Debug.WriteLine($"ConfirmationTimeoutChecker: confirmation {confirmation.Id} tried to confirm nonexistent message.");
confirmation.Errors |= Errors.ConfirmedNonexistent;
}
else
{
message.IsConfirmed = true;
if (IsTimeoutExceeded(message, confirmation))
{
SetTimeoutError(message);
OnTimeoutOccured(message);
}
_processedMessages.Add(message);
}
_processedConfirmations.Add(confirmation);
using (_currentlyProcessingIdLock.Write())
_currentlyProcessingId = string.Empty;
}
private void AssignIdIfNeeded(IMessageModel message)
{
if (string.IsNullOrWhiteSpace(message.Id))
{
message.Id = _context.IdGenerator.GetNewID();
}
}
public IMessageModel ClearFlagsIn(IMessageModel message)
{
_ = message ?? throw new System.ArgumentNullException(nameof(message));
message.Errors &= ~Errors.UndeterminedType;
return(message);
}
private bool CheckNextUnconfirmedMessage()
{
IMessageModel message = GetNextUnconfirmedMessage();
if (message is null)
{
return(false);
}
using (_currentlyProcessingIdLock.Read())
{
if (_currentlyProcessingId == message.Id)
{
return(false);
}
else
{
ClearTimeoutError(message);
if (IsTimeoutExceeded(message))
{
HandleExceededTimeout(message);
OnTimeoutOccured(message);
return(true);
}
return(false);
}
}
}
/// <summary>
/// Sends a <see cref="IMessageModel"/> by pipeline.
/// </summary>
/// <param name="message"><see cref="IMessageModel"/> to be sent</param>
/// <returns>True if <see cref="IMessageModel"/> sent successfully</returns>
public async Task <bool> SendAsync(IMessageModel message)
{
message.Timestamp = Timestamp.TimestampNow;
if (!CanSend(message))
{
SendFailureHandler(message);
return(false);
}
AssignIdIfNeeded(message);
if (await _context.Messenger.SendAsync(message).ConfigureAwait(false))
{
_sentMessages.TryAdd(message.Id, message);
message.IsTransfered = true;
if (!IsConfirmation(message))
{
AddToConfirmationTimeoutChecking(message);
OnMessageSent(message);
}
else
{
OnConfirmationSent(message);
}
return(true);
}
SendFailureHandler(message);
return(false);
}
public async Task Create(IMessageModel message)
{
await Task.Run(() =>
{
message.Id = _nextId++;
_messages.Add(message);
});
}
private void HandleMessageTimeout(IMessageModel message)
{
if (message is null)
{
return;
}
MarkAsTimeoutAndComplete(message);
}
public void AddToCheckingQueue(IMessageModel message)
{
if (message is null)
{
return;
}
lock (_getNextMessageLock)
_storage.Add(message.Timestamp, message);
}
private async Task SendConfirmationOfAsync(IMessageModel message)
{
IMessageModel confirmation = _context.ConfirmationFactory.GenerateConfirmationOf(message);
if (await SendAsync(confirmation).ConfigureAwait(false))
{
_sentMessages.TryAdd(confirmation.Id, confirmation);
}
}
public IMessageModel GenerateConfirmationOf(IMessageModel message)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message), "ConfirmationFactory - GenerateConfirmationOf: Cannot create confirmation of NULL");
}
IMessageModel confirmation = _messageFactory.CreateNew(Direction.Outgoing,
MessageType.Confirmation,
message.Id);
confirmation.Add(_commandFactory.Create(CommandType.HandShake));
confirmation.Add(_commandFactory.Create(CommandType.Confirmation));
foreach (var c in message)
{
ICommandModel responseCommand = _commandFactory.Create(timestampOverride: confirmation.Timestamp);
switch (c.CommandType)
{
case CommandType.Error:
responseCommand.CommandType = CommandType.ReceivedAsError;
break;
case CommandType.Unknown:
responseCommand.CommandType = CommandType.ReceivedAsUnknown;
break;
case CommandType.Partial:
responseCommand.CommandType = CommandType.ReceivedAsPartial;
break;
default:
responseCommand.CommandType = CommandType.ReceivedAsCorrect;
break;
}
confirmation.Add(responseCommand);
}
if (message.Errors.HasFlag(Errors.CompletitionTimeout))
{
confirmation.Add(_commandFactory.Create(CommandType.CompletitionTimeoutOccured));
}
if (message.Errors.HasFlag(Errors.ConfirmationTimeout))
{
confirmation.Add(_commandFactory.Create(CommandType.ConfirmationTimeoutOccurred));
}
confirmation.Add(_commandFactory.Create(CommandType.EndMessage));
// Assigns id also to all commands inside
confirmation.AssaignID(message.Id);
confirmation.AssighHostID(_hostId);
return(confirmation);
}
public IMessageModel ClearFlagsIn(IMessageModel message)
{
_ = message ?? throw new ArgumentNullException(nameof(message));
ClearErrorFlag(Errors.GotUnknownCommands, message);
ClearErrorFlag(Errors.GotErrorCommands, message);
ClearErrorFlag(Errors.GotPartialCommands, message);
return(message);
}
public IMessageModel ClearFlagsIn(IMessageModel message)
{
_ = message ?? throw new ArgumentNullException(nameof(message));
if (message.Errors.HasFlag(Errors.BadMessagePattern))
{
message.Errors &= ~Errors.BadMessagePattern;
}
return(message);
}
public void AddConfirmation(IMessageModel confirmation)
{
if (confirmation is null)
{
return;
}
_confirmations.Add(confirmation.Id, confirmation);
CheckMessageConfirmedBy(confirmation);
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> suspensionState)
{
IMessageModel model = parameter as IMessageModel;
if (model != null)
{
SetModelMessage(model);
}
await Task.CompletedTask;
}
public MainPresenter(IView view, IModelGemetic model, IFabricFileDocument modelSave, IMessageModel modelMessage)
{
_view = view ;
_model = model ;
_modelSave = modelSave;
_modelMessage = modelMessage;
_view.calculateEvent +=new EventHandler(_view_calculateEvent);
_view.saveFileDocument +=new EventHandler(_view_saveFileDocument);
_model.showProgress += new EventHandler(_model_showProgress);
}
public async Task RetryFailedSends()
{
foreach (var kvp in _failedSendMessages)
{
IMessageModel message = kvp.Value;
if (CanSend(message) && await SendAsync(message).ConfigureAwait(false))
{
_failedSendMessages.TryRemove(kvp.Key, out _);
}
}
}
public void AddMessage(IMessageModel message)
{
_repositories?.MessagesStore?.AddMessageItem(new MessageItem
{
UserName = message.UserName,
Email = message.Email,
Message = message.Message,
SentDate = message.SentDate
});
_repositories?.MessagesStore?.SaveMessages();
}
public IMessageModel CheckAndSetFlagsIn(IMessageModel message)
{
_message = ClearFlagsIn(message);
_message.Type = DetectType();
if (_message.Type == MessageType.Unknown)
{
_message.Errors |= Errors.UndeterminedType;
}
return(_message);
}
private IMessageModel CreateNewIncomingMessage(string id, ICommandModel commandToBaseOn)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentException("Id cannot be empty", nameof(id));
}
IMessageModel message = _msgFactory.CreateNew(direction: Enums.Direction.Incoming, id: id, timestampOverride: commandToBaseOn.TimeStamp, hostId: commandToBaseOn.HostId);
_idGenerator.MarkAsUsedUp(id);
return(message);
}
public bool IsTimeoutExceeded(IMessageModel message, IMessageModel confirmation = null)
{
_ = message ?? throw new ArgumentNullException(nameof(message), "TimeoutChecker - Check: Cannot check timeout for NULL.");
confirmation = confirmation is null?GetConfirmationOf(message) : null;
bool isTimeoutExceeded = confirmation is null
? _timeoutCheck.IsExceeded(message)
: _timeoutCheck.IsExceeded(message, confirmation);
return(isTimeoutExceeded);
}
public void PushFromIncompleteToProcessed(IMessageModel message)
{
_ = message ?? throw new ArgumentNullException(nameof(message));
lock (_processingLock)
if (_incompleteMessages.TryRemove(message.Id, out IMessageModel transferedMessage))
{
if (_completedMessages.TryAdd(transferedMessage.Id, transferedMessage))
{
_processedMessages.Add(message);
}
}
}
/// <summary>
/// 执行命令消息
/// </summary>
/// <param name="message"></param>
public void ExecuteCommand(IMessageModel message)
{
Type commandType = null;
List <IView> views = null;
lock (m_syncRoot)
{
#region Sreach Command Line
if (m_commandMap.ContainsKey(message.Name))
{
commandType = m_commandMap[message.Name];
}
else
{
views = new List <IView>();
foreach (KeyValuePair <IView, List <string> > keyValuePair in m_viewCommandMap)
{
if (keyValuePair.Value.Contains(message.Name))
{
views.Add(keyValuePair.Key);
}
}
}
#endregion
#region Command Line
if (commandType != null)
{
object commandInstance = Activator.CreateInstance(commandType);
ICommand command = commandInstance as ICommand;
if (command != null)
{
command.Execute(message);
}
}
#endregion
#region Send View Message
if (views != null && views.Count > 0)
{
int viewsCount = views.Count;
for (int i = 0; i < viewsCount; i++)
{
IView view = views[i];
view.OnMessage(message);
}
views = null;
}
#endregion
}
}
public IMessageModel CheckAndSetFlagsIn(IMessageModel message)
{
_message = ClearFlagsIn(message);
if (CheckPattern())
{
return(_message);
}
else
{
_message.Errors |= Errors.BadMessagePattern;
return(_message);
}
}
public async Task Create(IMessageModel message)
{
var p = new
{
message.ToName,
message.FromName,
message.MessageText,
message.TimeCreated,
message.LocationCreated,
message.IsTestObject
};
await _dataAccess.SaveData("dbo.spMessage_Create", p, "SQLDB");
}
public bool IsComplete(IMessageModel message)
{
_ = message ?? throw new ArgumentNullException(nameof(message));
if (message.IsCompleted)
{
return(true);
}
if (message.Count() >= 4 && IsSecondCommandAType(message.Commands[1].CommandType) && message.Last().CommandType == CommandType.EndMessage)
{
return(message.IsCompleted = true);
}
return(false);
}
private void HandleExceededTimeout(IMessageModel message)
{
SetTimeoutError(message);
if (GetConfirmationOf(message) is null)
{
SetNoConfirmatioError(message);
}
_processedMessages.Add(message);
lock (_getNextMessageLock)
if (_storage[_storage.Keys.First()].Timestamp == message.Timestamp)
{
_storage.Remove(_storage.Keys.First());
}
_processingCTS.Token.ThrowIfCancellationRequested();
}
public IMessageModel CreateNew(
Enums.Direction direction = Enums.Direction.Unknown,
Enums.MessageType type = Enums.MessageType.Unknown,
string idOverride = "",
string hostIdOverride = "",
long timestampOverride = 0)
{
IMessageModel output = _messageFactory();
output.AssaignID(string.IsNullOrWhiteSpace(idOverride) ? string.Empty : idOverride);
output.AssighHostID(string.IsNullOrWhiteSpace(hostIdOverride)? string.Empty : hostIdOverride);
output.Type = type;
output.Direction = direction;
output.Timestamp = timestampOverride < 0 ? Timestamp.TimestampNow : timestampOverride;
return(output);
}
public async Task <bool> SendAsync(IMessageModel message)
{
if (message is null)
{
return(false);
}
var results = new List <bool>();
foreach (ICommandModel c in message)
{
results.Add(await SendAsync(c).ConfigureAwait(false));
}
return(results.Contains(false) ? false : true);
}
public override void Execute(IMessageModel message)
{
//------------------------添加管理器对象-----------------------------
AppBridgeLink.Instance.AddManager <NetWorkManager>(ManagerName.NET_WORK);
//AppBridgeLink.Instance.AddManager<MusicManager>(ManagerName.MUSIC);
AppBridgeLink.Instance.AddManager <TimerManager>(ManagerName.TIMER);
//AppBridgeLink.Instance.AddManager<ImageCacheManager>(ManagerName.IMAGE_CACHE);
AppBridgeLink.Instance.AddManager <NotificationManager>(ManagerName.NOTIFICATION);
AppBridgeLink.Instance.AddManager <CoroutineManager>(ManagerName.COROUTINE);
AppBridgeLink.Instance.AddManager <SceneManager>(ManagerName.SCENE);
AppBridgeLink.Instance.AddManager <DataCacheManager>(ManagerName.DATACACHE);
AppBridgeLink.Instance.AddManager <DownLoadManager>(ManagerName.DOWNLOAD);
// AppBridgeLink.Instance.AddManager<DataStatisticsManager>(ManagerName.DATA_STATISTICS);
AppBridgeLink.Instance.AddManager <AssetBundleManager>(ManagerName.ASSET_BUNDLE);
// AppBridgeLink.Instance.AddManager<ImageTargetManager>(ManagerName.IMAGE_TARGET);
//AppBridgeLink.Instance.AddManager<LanguagePackageManager>(ManagerName.LANGUAGE_PACKAGE);
}
public void ParseLog(string search, IMessageModel messageModel)
{
if (search == null || messageModel == null)
{
return;
}
// [2017-05-20 19:04:51 UTC] xxxx: xxxx
var text = string.Empty;
foreach (var s in messageModel.UnEditedText)
{
if (s.ToLower().Contains(search.ToLower()))
{
text = text + $"{s}\n";
}
}
messageModel.Text = text;
}
public async Task <bool> SendMessage(string SenderId, string RecipientId, IMessageModel Message)
{
if (Helpers.FullVerifyGuid(ref SenderId, logger) is false)
{
return(false);
}
if (Helpers.FullVerifyGuid(ref RecipientId, logger) is false)
{
return(false);
}
try
{
// get the serialized messages list
var result = await db.ExecuteSingleProcedure <string, dynamic>(GetMessagesProcedure, new { Id = RecipientId });
// if the list is null just create a new one
List <MessageModel> messages = result is null ? new() : Newtonsoft.Json.JsonConvert.DeserializeObject <List <MessageModel> >(result);
// add it to the list
if (Message is MessageModel mm)
{
// add the message
if (messages.Contains(mm) is false)
{
messages.Add(mm);
}
}
// serialize the list for storage
result = Newtonsoft.Json.JsonConvert.SerializeObject(messages);
// save the messages
await db.ExecuteVoidProcedure <dynamic>(SetMessagesProcedure, new { Id = RecipientId, Messages = result });
return(true);
}
catch (Exception e)
{
logger.LogError("Failed to send message From {SenderId} to {RecipientId} Error: {Error}", SenderId, RecipientId, e);
return(false);
}
}
public MessageCtrl(IMessageModel model)
{
Model = model;
}
private void SetModelMessage(IMessageModel messageModel)
{
Header = messageModel.Header == null ? "" : messageModel.Header;
UserSend = messageModel.UserSend == null ? "" : messageModel.UserSend;
Content = messageModel.Content == null ? "" : messageModel.Content;
}
public EmailService(EmailType EmailType, IMessageModel Message) {
CurrEmailType = EmailType;
this.Message = Message;
}
