private async Task ParseServerToClientMessage(CoreComMessageResponse request)
{
using (var dbContext = new CoreComContext(_dbContextOptions))
{
request.TransferStatus = (int)TransferStatusEnum.Recived;
request.RecivedUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime();
if (request.MessageSignature == CoreComInternalSignatures.CoreComInternal_PullQueue)
{
await ParseCoreComFrameworkFromServerMessage(request).ConfigureAwait(false);
LogEventOccurred(dbContext, request);
return;
}
LogEventOccurred(dbContext, request);
//System.Type type = Type.GetType(request.JsonObjectType);
// erer = new CoreComMessagingCenter();
Type type = CoreComMessagingCenter.GetMessageArgType(request.MessageSignature);
if (type == null)
{
CoreComMessagingCenter.Send(request.MessageSignature, null);
}
else
{
var objectDeser = JsonSerializer.Deserialize(request.JsonObject, type);
CoreComMessagingCenter.Send(request.MessageSignature, null, objectDeser);
}
//CoreComUserInfo coreComUserInfo = new CoreComUserInfo { ClientId = request.ClientId };
//if (string.IsNullOrEmpty(request.JsonObject))
//{
// var funcToRun = _receiveDelegatesOneParm.FirstOrDefault(x => x.Item2 == request.MessageSignature);
// if (funcToRun != null)
// {
// await funcToRun.Item1.Invoke(coreComUserInfo).ConfigureAwait(false);
// }
// else
// {
// LogErrorOccurred("No function mapped to " + request.MessageSignature, request);
// }
//}
//else
//{
// var funcToRun = _receiveDelegatesTwoParm.FirstOrDefault(x => x.Item2 == request.MessageSignature);
// if (funcToRun != null)
// {
// var objectDeser = JsonSerializer.Deserialize(request.JsonObject, funcToRun.Item3);
// await funcToRun.Item1.Invoke(objectDeser, coreComUserInfo).ConfigureAwait(false);
// }
// else
// {
// LogErrorOccurred("No function mapped to " + request.MessageSignature, request);
// }
//}
}
}
internal async virtual void LogErrorOccurred(string description, CoreComMessageResponse coreComMessage, Exception ex = null)
{
LogError logError = new LogError {
Description = description
};
if (coreComMessage != null)
{
logError.ClientId = coreComMessage.ClientId;
logError.TransactionIdentifier = coreComMessage.TransactionIdentifier;
if (string.IsNullOrEmpty(description))
{
logError.Description = coreComMessage.MessageSignature;
}
}
if (ex != null)
{
logError.Stacktrace = ex.StackTrace;
}
using (var dbContext = new CoreComContext(_dbContextOptions))
{
//Messages
switch (_coreComOptions.LogSettings.LogErrorTarget)
{
case LogErrorTargetEnum.Database:
dbContext.LogErros.Add(logError);
break;
case LogErrorTargetEnum.TextFile:
//Create textfile log
// await WriteErrorLogtoFile(logError).ConfigureAwait(false);
break;
case LogErrorTargetEnum.NoLoging:
//if (coreComMessage.TransferStatus != (int)TransferStatusEnum.New)
// dbContext.IncomingMessages.Remove(coreComMessage);
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
EventHandler <LogError> handler = OnLogErrorOccurred;
if (handler != null)
{
handler(this, logError);
}
}
private async Task WriteIncommingMessagesLog(CoreComMessageResponse request)
{
if (_coreComOptions.LogSettings.LogMessageTarget != LogMessageTargetEnum.TextFile)
{
return;
}
// Set a variable to the Documents path.
string docPath = FileSystem.AppDataDirectory;// Environment.CurrentDirectory;
// Write the specified text asynchronously to a new file named "WriteTextAsync.txt".
using (StreamWriter outputFile = new StreamWriter(Path.Combine(docPath, "IncommingMessages.log"), true))
{
await outputFile.WriteLineAsync(DateTime.UtcNow.ToString() + "\t" + request.CoreComMessageResponseId + "\t" + request.MessageSignature + "\t" + request.ClientId + "\t" + request.TransactionIdentifier + "\t" + ((TransferStatusEnum)request.TransferStatus).ToString() + "\t" + request.CalculateSize().ToString() + Environment.NewLine);
}
}
private async Task <bool> SendInternalAsync(object outgoingObject, string messageSignature, CoreComUserInfo coreComUserInfo)
{
string jsonObject = string.Empty;
CoreComMessageResponse coreComMessage;
//Build message
try
{
//error report to client
if (outgoingObject != null)
{
jsonObject = JsonSerializer.Serialize(outgoingObject);
}
coreComMessage = new CoreComMessageResponse
{
CoreComMessageResponseId = Guid.NewGuid().ToString(),
ClientId = coreComUserInfo.ClientId,
NewUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime(),
TransactionIdentifier = Guid.NewGuid().ToString(),
MessageSignature = messageSignature,
JsonObject = jsonObject
};
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
LogEventOccurred(dbContext, coreComMessage);
}
}
catch (Exception ex)
{
LogErrorOccurred(ex, new CoreComMessage {
ClientId = coreComUserInfo.ClientId, MessageSignature = messageSignature
});
return(false);
}
return(true);
}
private async Task ParseCoreComFrameworkMessage(CoreComMessage request)
{
//We need always responde with a message other vise loggin on client not work
//and the same CoreComInternal_PullQueue from client will send and wo will have the same
//transactionId twice result in db error
using (var dbContext = new CoreComContext(_coreComOptions.DbContextOptions))
{
//queue is empty then create response message
if (!dbContext.OutgoingMessages.Any(x => x.ClientId == request.ClientId && x.TransferStatus < (int)TransferStatusEnum.Transferred))
{
//send
var internalMess = new CoreComMessageResponse
{
MessageSignature = CoreComInternalSignatures.CoreComInternal_PullQueue,
CoreComMessageResponseId = Guid.NewGuid().ToString(),
ClientId = request.ClientId,
NewUtc = Helpers.DateTimeConverter.DateTimeUtcNowToUnixTime(),
TransactionIdentifier = Guid.NewGuid().ToString()
};
LogEventOccurred(dbContext, internalMess);
}
}
}
internal async virtual void LogErrorOccurred(Exception exception, CoreComMessageResponse coreComMessage)
{
LogErrorOccurred(exception.Message, coreComMessage, exception);
}
internal async virtual void LogEventOccurred(CoreComContext dbContext, CoreComMessageResponse coreComMessageResponse)
{
LogEvent logEvent = new LogEvent {
Description = coreComMessageResponse.MessageSignature, TransferStatus = (TransferStatusEnum)coreComMessageResponse.TransferStatus, MessageSize = coreComMessageResponse.CalculateSize()
};
//Messages
switch (_coreComOptions.LogSettings.LogMessageTarget)
{
case LogMessageTargetEnum.Database:
//allways remove CoreComInternal from incomming table/ the massage is new so it does not exist in table
if (coreComMessageResponse.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue)
{ //add incomming message to db
coreComMessageResponse.CoreComMessageResponseId = Guid.NewGuid().ToString();
dbContext.IncomingMessages.Add(coreComMessageResponse);
}
break;
case LogMessageTargetEnum.TextFile:
if (coreComMessageResponse.MessageSignature != CoreComInternalSignatures.CoreComInternal_PullQueue)
{ //add incomming message to file
await WriteIncommingMessagesLog(coreComMessageResponse);
}
break;
case LogMessageTargetEnum.NoLoging:
//dbContext.OutgoingMessages.Remove(coreComMessage);
break;
default:
break;
}
//Events
switch (_coreComOptions.LogSettings.LogEventTarget)
{
case LogEventTargetEnum.Database:
if (coreComMessageResponse.TransferStatus != (int)TransferStatusEnum.New)
{
await dbContext.LogEvents.AddAsync(logEvent);
}
break;
case LogEventTargetEnum.TextFile:
await WriteEventLogtoFile(logEvent);
break;
case LogEventTargetEnum.NoLoging:
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
EventHandler <LogEvent> handler = OnLogEventOccurred;
if (handler != null)
{
handler(this, logEvent);
}
}
private async Task ParseCoreComFrameworkFromServerMessage(CoreComMessageResponse request)
{
}
internal async virtual void LogEventOccurred(CoreComContext dbContext, CoreComMessageResponse coreComMessageResponse)
{
LogEvent logEvent = new LogEvent
{
Description = coreComMessageResponse.MessageSignature,
ClientId = coreComMessageResponse.ClientId,
TransactionIdentifier = coreComMessageResponse.TransactionIdentifier,
TransferStatus = (TransferStatusEnum)coreComMessageResponse.TransferStatus,
MessageSize = coreComMessageResponse.CalculateSize()
};
//allways add to new outgoing to database
if (coreComMessageResponse.TransferStatus == (int)TransferStatusEnum.New)
{
dbContext.OutgoingMessages.Add(coreComMessageResponse);
}
//Messages
switch (_coreComOptions.LogSettings.LogMessageTarget)
{
case LogMessageTargetEnum.Database:
//status change will be writen to database on dbContext.SaveChangesAsync
//we don't save Pullqueue messages
if (coreComMessageResponse.TransferStatus == (int)TransferStatusEnum.Transferred &&
coreComMessageResponse.MessageSignature == CoreComInternalSignatures.CoreComInternal_PullQueue)
{ //remove message
dbContext.OutgoingMessages.Remove(coreComMessageResponse);
}
break;
case LogMessageTargetEnum.TextFile:
//Create textfile log
//add response message to file
await WriteOutgoingMessagesLog(coreComMessageResponse);
break;
case LogMessageTargetEnum.NoLoging:
if (coreComMessageResponse.TransferStatus == (int)TransferStatusEnum.Transferred)
{ //remove message
dbContext.OutgoingMessages.Remove(coreComMessageResponse);
}
break;
default:
break;
}
//Events
switch (_coreComOptions.LogSettings.LogEventTarget)
{
case LogEventTargetEnum.Database:
if (coreComMessageResponse.TransferStatus != (int)TransferStatusEnum.New)
{
await dbContext.LogEvents.AddAsync(logEvent);
}
break;
case LogEventTargetEnum.TextFile:
//Create textfile log
await WriteEventLogtoFile(logEvent).ConfigureAwait(false);
break;
case LogEventTargetEnum.NoLoging:
break;
default:
break;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
EventHandler <LogEvent> handler = OnLogEventOccurred;
if (handler != null)
{
handler(this, logEvent);
}
}
