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); }