public IEricaChats_MessageDTO PUT(IEricaChats_MessageDTO request)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
ChatMessage chatMessageInput = MaptoChatMessage(request);
if (chatMessageInput.Channel == null)
{
return(SetErrorMessageForInvalidChatChannel(request));
}
chatMessageInput.ModifiedDateTime = DateTime.Now;
ChatMessage updatedChatMessage = this.ChatMessages.Find(chatMessageInput.ChatMessageID);
//NOTE: Ensure the CreatedDateTime isn't modified by the client.
chatMessageInput.CreatedDateTime = updatedChatMessage.CreatedDateTime;
this.Entry(updatedChatMessage).CurrentValues.SetValues(chatMessageInput);
this.SaveChanges();
dbContextTransaction.Commit();
IEricaChats_MessageDTO recipt = MapToDTO(updatedChatMessage);
return(recipt);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public IEricaChats_MessageDTO POST(IEricaChats_MessageDTO request)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
ChatMessage chatMessageInput = MaptoChatMessage(request);
if (chatMessageInput.Channel == null)
{
return(SetErrorMessageForInvalidChatChannel(request));
}
chatMessageInput.CreatedDateTime = DateTime.Now;
this.ChatMessages.Add(chatMessageInput);
this.SaveChanges();
dbContextTransaction.Commit();
IEricaChats_MessageDTO recipt = MapToDTO(chatMessageInput);
return(recipt);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public object Consume(IEricaMQ_MessageDTO message)
{
//TODO: Add some filtering ???
IEricaChats_MessageDTO ericaChatsMessage = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(message.Data);
ericaChatsMessage.ChatMessageBody += " Consumed"; //NOTE: Just for testing
//TODO: Add a Slack integration here :=)
return(JsonMarshaller.Marshall(ericaChatsMessage));
}
private async Task UploadFileToFileManager(IEricaChats_MessageDTO ericaMessageRequest)
{
IEricaChats_FileDTO ericaChats_FileDTO = new EricaChats_FileDTO();
ericaChats_FileDTO.FileNameGuid = ericaMessageRequest.FileAttachmentGUID;
ericaChats_FileDTO.FileBytesAsAsBase64String = ericaMessageRequest.FileBytesAsAsBase64String;
string ericaChats_FileDTO_Json = JsonMarshaller.Marshall(ericaChats_FileDTO);
var client = _httpClientFactory.CreateClient();
var content = new StringContent(ericaChats_FileDTO_Json, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync("http://localhost:50002/api/EricaChatsFiles/UploadFile", content);
response.EnsureSuccessStatusCode();
}
public ChatMessage MaptoChatMessage(IEricaChats_MessageDTO request)
{
try
{
ChatMessage chatMessage = new ChatMessage();
chatMessage.Channel = MapToChannel(request);
chatMessage.ChannelID = chatMessage.Channel.ChannelID;
chatMessage.ChatMessageID = request.ChatMessageID;
chatMessage.ChatMessageBody = request.ChatMessageBody;
chatMessage.SenderUserName = request.SenderUserName;
chatMessage.FileAttachmentGUID = request.FileAttachmentGUID;
chatMessage.FriendlyFileName = request.FriendlyFileName;
return(chatMessage);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public async Task <IEricaMQ_MessageDTO> Produce(object request)
{
try
{
//TODO: Remmber to add a filter here so I don't process wrong messages.
IEricaChats_MessageDTO ericaMessageRequest = (IEricaChats_MessageDTO)request;
IEricaChats_MessageDTO ericaMessageProcessed;
IEricaMQ_MessageDTO mqMessage = new EricaMQ_Message();
if (String.IsNullOrEmpty(ericaMessageRequest.FileAttachmentGUID) == false &&
String.IsNullOrEmpty(ericaMessageRequest.FriendlyFileName) == false &&
String.IsNullOrEmpty(ericaMessageRequest.FileBytesAsAsBase64String) == false)
{
//NOTE: If there is a file attachement upload it to the File Manager, all updates will cause original to be versioned.
await UploadFileToFileManager(ericaMessageRequest);
}
if (ericaMessageRequest.ChatMessageID > 0)
{
ericaMessageProcessed = _ericaChats_DBContext.PUT(ericaMessageRequest);
mqMessage.Context = EricaChatsConstants.Context_UpdateChatMessage;
mqMessage.Sender = ericaMessageProcessed.SenderUserName;
mqMessage.Data = JsonMarshaller.Marshall(ericaMessageProcessed);
mqMessage.AdapterAssemblyQualifiedName = typeof(IEricaChatsSimpleConsumerAdapter).AssemblyQualifiedName;
}
else
{
ericaMessageProcessed = _ericaChats_DBContext.POST(ericaMessageRequest);
mqMessage.Context = EricaChatsConstants.Context_CreateChatMessage;
mqMessage.Sender = ericaMessageProcessed.SenderUserName;
mqMessage.Data = JsonMarshaller.Marshall(ericaMessageProcessed);
mqMessage.AdapterAssemblyQualifiedName = typeof(IEricaChatsSimpleConsumerAdapter).AssemblyQualifiedName;
}
return(mqMessage);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public void TestPost()
{
IEricaChats_MessageDTO ericaDTO = new EricaChats_MessageDTO();
ericaDTO.ChatChannelID = 1;
ericaDTO.ChatChannelName = "Christ";
ericaDTO.SenderUserName = "******";
ericaDTO.ChatMessageBody = "Love thy neighbore as thyself";
string mqRequest = JsonMarshaller.Marshall(ericaDTO);
HttpResponseMessage response = GetRequestResponse(mqRequest);
Assert.IsTrue(response.IsSuccessStatusCode);
string contentBody = GetContentBody(response);
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
IEricaChats_MessageDTO mqProducerResponse = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(contentBody);
Assert.IsNotNull(mqProducerResponse);
Assert.IsTrue(String.IsNullOrEmpty(mqProducerResponse.ErrorMessage));
}
public async Task <JsonResult> Put(IEricaChats_MessageDTO request)
{
try
{
if (request.ChatMessageID < 1)
{
request.ErrorMessage = "ChatMessageID must be greater than 0 on a PUT requst";
return(new JsonResult(request, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
}));
}
else
{
return(await ProcessRequest(request));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw new ApplicationException(ex.Message, ex);
}
}
public void TestPut()
{
IEricaChats_MessageDTO ericaDTO = new EricaChats_MessageDTO();
ericaDTO.ChatChannelID = 1;
ericaDTO.ChatChannelName = "Christ";
ericaDTO.SenderUserName = "******";
ericaDTO.ChatMessageBody = "Love thy neighbore as thyself";
string mqRequest = JsonMarshaller.Marshall(ericaDTO);
HttpResponseMessage response = GetRequestResponse(mqRequest);
Assert.IsTrue(response.IsSuccessStatusCode);
string contentBody = GetContentBody(response);
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
IEricaChats_MessageDTO mqProducerResponse = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(contentBody);
Assert.IsNotNull(mqProducerResponse);
string newSenderUserName = "******";
mqProducerResponse.SenderUserName = newSenderUserName;
//******* Test the PUT
string mqUpdatedRequest = JsonMarshaller.Marshall(mqProducerResponse);
HttpResponseMessage updatedResponse = GetRequestResponse(mqUpdatedRequest, true);
Assert.IsTrue(updatedResponse.IsSuccessStatusCode);
string updatedContentBody = GetContentBody(updatedResponse);
Assert.IsFalse(String.IsNullOrEmpty(updatedContentBody));
IEricaChats_MessageDTO updatedMqProducerResponse = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(updatedContentBody);
Assert.AreEqual(newSenderUserName, updatedMqProducerResponse.SenderUserName);
Assert.IsTrue(String.IsNullOrEmpty(updatedMqProducerResponse.ErrorMessage));
}
public Channel MapToChannel(IEricaChats_MessageDTO request)
{
try
{
Channel channel = new Channel();
if (request.ChatChannelID > 0)
{
channel = this.Channels.Find(request.ChatChannelID);
}
else if (String.IsNullOrEmpty(request.ChatChannelName) == false)
{
channel = this.Channels.FirstOrDefault(chnl => chnl.ChannelName == request.ChatChannelName);
}
else
{
channel = null;
}
return(channel);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
private async Task <JsonResult> ProcessRequest(IEricaChats_MessageDTO request)
{
try
{
IEricaMQ_MessageDTO mqMessage = await _ericaChatsSimpleProducerAdapter.Produce(request);
string jsonMqMessage = JsonMarshaller.Marshall(mqMessage);
IEricaChats_MessageDTO jsonRecipt = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(mqMessage.Data);
var discover = await DiscoveryClient.GetAsync(Constants_IdentityServer.IdentityServerUrl);
if (discover.IsError)
{
throw new ApplicationException(discover.Error);
}
var tokenClient = new TokenClient(discover.TokenEndpoint, Constants_IdentityServer.EricaMQProducer_Client, Constants_IdentityServer.EricaMQProducer_ClientSecret);
var tokenResponse = await tokenClient.RequestClientCredentialsAsync(Constants_IdentityServer.EricaMQ_Api);
if (tokenResponse.IsError)
{
throw new ApplicationException(tokenResponse.Error);
}
var client = _httpClientFactory.CreateClient();
client.SetBearerToken(tokenResponse.AccessToken);
var content = new StringContent(jsonMqMessage, Encoding.UTF8, "application/json");
Task <HttpResponseMessage> mqTask = client.PostAsync("http://localhost:80/api/ericamq", content);
HttpResponseMessage mqResponse = null;
string errorLog = string.Empty;
await mqTask;
switch (mqTask.Status)
{
case TaskStatus.Faulted:
DateTime timeStamp = DateTime.Now;
errorLog = $"Error while Posting to EricaMQ at {timeStamp} - Details on next line \n {mqTask.Exception.Flatten().InnerException.Message}";
_logger.LogError(errorLog);
jsonRecipt.ErrorMessage = $"Could not post your request to the erica message queue. {timeStamp}";
break;
case TaskStatus.RanToCompletion:
mqResponse = mqTask.Result;
if (mqResponse.IsSuccessStatusCode == false)
{
DateTime timeStampStatusCode = DateTime.Now;
jsonRecipt.ErrorMessage = errorLog = $"Your request to the EricaMQ returned a status code of {mqResponse.StatusCode} at time {timeStampStatusCode}";
_logger.LogError(errorLog);
}
break;
}
return(new JsonResult(jsonRecipt, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
}));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw new ApplicationException(ex.Message, ex);
}
}
public void TestGetLatestMessage()
{
try
{
TokenResponse tokenResponse = null;
var tokenResponseTask = GetAccessToken();
tokenResponseTask.Wait();
switch (tokenResponseTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(tokenResponseTask.Exception.Flatten().InnerException.Message, tokenResponseTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
tokenResponse = tokenResponseTask.Result;
break;
}
List <IEricaMQ_MessageDTO> newMessagesList = new List <IEricaMQ_MessageDTO>();
List <IEricaChats_MessageDTO> newMessagesList2 = new List <IEricaChats_MessageDTO>();
HubConnection connection = new HubConnectionBuilder()
.WithUrl("http://localhost:80/api/ericamqhub",
options =>
{
options.AccessTokenProvider = () => Task.FromResult(tokenResponse.AccessToken);
}
)
.Build();
connection.On <string>(Constants_EricaMQ_Hub.ClientEvent_ReceiveLatestMessage, (message) =>
{
IEricaMQ_MessageDTO mQ_MessageDTO = JsonMarshaller.UnMarshall <EricaMQ_Message>(message);
Assert.IsNotNull(mQ_MessageDTO);
newMessagesList.Add(mQ_MessageDTO);
});
connection.StartAsync().Wait();
connection.InvokeAsync <bool>(Constants_EricaMQ_Hub.HubMethod_SubscribeToLatestMessage).Wait();
TokenResponse tokenResponse2 = null;
var tokenResponseTask2 = GetAccessToken();
tokenResponseTask2.Wait();
switch (tokenResponseTask2.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(tokenResponseTask2.Exception.Flatten().InnerException.Message, tokenResponseTask2.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
tokenResponse2 = tokenResponseTask2.Result;
break;
}
HubConnection connection2 = new HubConnectionBuilder()
.WithUrl("http://localhost:80/api/ericamqhub",
options =>
{
options.AccessTokenProvider = () => Task.FromResult(tokenResponse.AccessToken);
}
)
.Build();
connection2.On <string>(Constants_EricaMQ_Hub.ClientEvent_ReceiveLatestConsumedMessage, (message) =>
{
IEricaChats_MessageDTO mQ_MessageDTO2 = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(message);
Assert.IsNotNull(mQ_MessageDTO2);
newMessagesList2.Add(mQ_MessageDTO2);
});
connection2.StartAsync().Wait();
connection2.InvokeAsync <bool>(Constants_EricaMQ_Hub.HubMethod_SubscribeToLatestMessage).Wait();
while (newMessagesList.Count < 3 && newMessagesList2.Count < 3)
{
//POST
IEricaChats_MessageDTO ericaChats = new EricaChats_MessageDTO();
ericaChats.ChatMessageID = 123;
ericaChats.ChatChannelID = 1;
ericaChats.ChatMessageBody = "Jesus Loves You. ";
ericaChats.CreatedDateTime = DateTime.Now;
ericaChats.ModifiedDateTime = DateTime.MinValue;
ericaChats.SenderUserName = "******";
IEricaMQ_MessageDTO ericaMQ_MessageDTOConsume = new EricaMQ_Message();
ericaMQ_MessageDTOConsume.Context = "UnitTestLatest";
ericaMQ_MessageDTOConsume.Data = JsonMarshaller.Marshall(ericaChats);
ericaMQ_MessageDTOConsume.Sender = "UnitTestLatest";
ericaMQ_MessageDTOConsume.AdapterAssemblyQualifiedName = typeof(IEricaChatsSimpleConsumerAdapter).AssemblyQualifiedName;
string mqRequestConsume = JsonMarshaller.Marshall(ericaMQ_MessageDTOConsume);
HttpResponseMessage responseConsume = null;
var requestConsumeTask = SendRequest(mqRequestConsume);
requestConsumeTask.Wait();
switch (requestConsumeTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(requestConsumeTask.Exception.Flatten().InnerException.Message, requestConsumeTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
responseConsume = requestConsumeTask.Result;
break;
}
Assert.IsTrue(responseConsume.IsSuccessStatusCode);
IEricaMQ_MessageDTO ericaMQ_MessageDTO = new EricaMQ_Message();
ericaMQ_MessageDTO.Context = "UnitTestLatest";
ericaMQ_MessageDTO.Data = "UnitTestLatest";
ericaMQ_MessageDTO.Sender = "UnitTestLatest";
string mqRequest = JsonMarshaller.Marshall(ericaMQ_MessageDTO);
HttpResponseMessage response = null;
var requestTask = SendRequest(mqRequest);
requestTask.Wait();
switch (requestTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(requestTask.Exception.Flatten().InnerException.Message, requestTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
response = requestTask.Result;
break;
}
Assert.IsTrue(response.IsSuccessStatusCode);
}
connection.StopAsync();
connection2.StopAsync();
foreach (var message in newMessagesList)
{
Assert.IsTrue(message.Id > 0);
}
foreach (var message in newMessagesList2)
{
Assert.IsTrue(message.ChatMessageID > 0);
}
}
catch (Exception)
{
throw;
}
}
public void TestGetNewMessagesHub()
{
try
{
TokenResponse tokenResponse = null;
var tokenResponseTask = GetAccessToken();
tokenResponseTask.Wait();
switch (tokenResponseTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(tokenResponseTask.Exception.Flatten().InnerException.Message, tokenResponseTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
tokenResponse = tokenResponseTask.Result;
break;
}
List <IEricaMQ_MessageDTO> newMessagesList = new List <IEricaMQ_MessageDTO>();
List <IEricaChats_MessageDTO> newMessagesListConsume = new List <IEricaChats_MessageDTO>();
HubConnection connection = new HubConnectionBuilder()
.WithUrl("http://localhost:80/api/ericamqhub", options =>
{
options.AccessTokenProvider = () => Task.FromResult(tokenResponse.AccessToken);
})
.Build();
connection.On <string>(Constants_EricaMQ_Hub.ClientEvent_ReceiveMessagesInRange, (message) =>
{
IEricaMQ_MessageDTO mqMessage = JsonMarshaller.UnMarshall <EricaMQ_Message>(message);
Assert.IsNotNull(mqMessage);
newMessagesList.Add(mqMessage);
});
connection.On <string>(Constants_EricaMQ_Hub.ClientEvent_ReceiveConsumedMessagesInRange, (message) =>
{
//NOTE: Client must know the expected type to be consumed
IEricaChats_MessageDTO mqMessage = JsonMarshaller.UnMarshall <EricaChats_MessageDTO>(message);
Assert.IsNotNull(mqMessage);
newMessagesListConsume.Add(mqMessage);
});
connection.StartAsync().Wait();
IEricaChats_MessageDTO ericaChats = new EricaChats_MessageDTO();
ericaChats.ChatMessageID = 123;
ericaChats.ChatChannelID = 1;
ericaChats.ChatMessageBody = "Jesus Loves You. ";
ericaChats.CreatedDateTime = DateTime.Now;
ericaChats.ModifiedDateTime = DateTime.MinValue;
ericaChats.SenderUserName = "******";
IEricaMQ_MessageDTO ericaMQ_MessageDTO = new EricaMQ_Message();
ericaMQ_MessageDTO.Context = "UnitTest-Consumed";
ericaMQ_MessageDTO.Data = JsonMarshaller.Marshall(ericaChats);
ericaMQ_MessageDTO.Sender = "UnitTest-Producer";
ericaMQ_MessageDTO.AdapterAssemblyQualifiedName = typeof(IEricaChatsSimpleConsumerAdapter).AssemblyQualifiedName;
string mqRequest = JsonMarshaller.Marshall(ericaMQ_MessageDTO);
HttpResponseMessage response = null;
var requestTask = SendRequest(mqRequest);
requestTask.Wait();
switch (requestTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(requestTask.Exception.Flatten().InnerException.Message, requestTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
response = requestTask.Result;
break;
}
DateTime afterTime = Convert.ToDateTime("2018-10-21 18:19:03.7618097"); //REMEMBER: Must choose this date wisely before running test (un-migrated data may cause test to fail)
Task <string> messageTask = connection.InvokeAsync <string>(Constants_EricaMQ_Hub.HubMethod_GetMessagesInRange, afterTime, 200, DateTime.MaxValue);
messageTask.Wait();
switch (messageTask.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(messageTask.Exception.Flatten().InnerException.Message, messageTask.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
afterTime = Convert.ToDateTime(messageTask.Result);
break;
}
afterTime = Convert.ToDateTime("2018-10-21 18:19:03.7618097"); //REMEMBER: Must choose this date wisely before running test (un-migrated data may cause test to fail)
Task <string> messageTaskConsume = connection.InvokeAsync <string>(Constants_EricaMQ_Hub.HubMethod_ConsumeMessagesInRange, afterTime, 200, DateTime.MaxValue);
messageTaskConsume.Wait();
switch (messageTaskConsume.Status)
{
case TaskStatus.Faulted:
throw new ApplicationException(messageTaskConsume.Exception.Flatten().InnerException.Message, messageTaskConsume.Exception.Flatten().InnerException);
case TaskStatus.RanToCompletion:
afterTime = Convert.ToDateTime(messageTaskConsume.Result);
break;
}
connection.StopAsync().Wait();
foreach (var message in newMessagesList)
{
Assert.IsTrue(message.Id > 0);
}
foreach (var message in newMessagesListConsume)
{
Assert.IsTrue(message.ChatMessageID > 0);
}
}
catch (Exception)
{
throw;
}
}
public IEricaChats_MessageDTO SetErrorMessageForInvalidChatChannel(IEricaChats_MessageDTO invalidRequest)
{
invalidRequest.ErrorMessage += String.Format("The chat channel name {0} that you provided does not exists. ", invalidRequest.ChatChannelName);
invalidRequest.ErrorMessage += String.Format("The chat channel ID {0} that you provided does not exists. ", invalidRequest.ChatChannelID);
return(invalidRequest);
}
