public async Task <bool> GetMessagesInRangeBulkList(DateTime afterThisTimeStamp, int maxAmount, DateTime beforeThisTimeStamp)
{
try
{
var newMessages = GetMessageListInRange(afterThisTimeStamp, maxAmount, beforeThisTimeStamp);
List <string> bulkList = new List <string>();
int percentComplete = 0;
foreach (var message in newMessages)
{
string marshalledMessage = JsonMarshaller.Marshall(message);
bulkList.Add(marshalledMessage);
percentComplete = (bulkList.Count / 100) * newMessages.Count;
await Clients.Caller.SendAsync(Constants_EricaMQ_Hub.ClientEvent_ReceiveMessagesInRangeBulkListProcessingProgress, percentComplete);
}
await Clients.Caller.SendAsync(Constants_EricaMQ_Hub.ClientEvent_ReceiveMessagesInRangeBulkList, bulkList);
return(true);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw new ApplicationException(ex.Message, ex);
}
}
/// <summary>
/// Searches for Matches to incomming XLinks, in the local WorkingDirectory
/// </summary>
public void searchForMatchesThread()
{
for (int i = 0; i < matchingObjects.Length; i++)
{
IMarshaller marseller = new JsonMarshaller();
OOClass currentPotentialMatch = marseller.UnmarshallObject <OOClass>(matchingObjects[i].ToString());
Program.directoryBrowser.searchForXLinkMatches(currentPotentialMatch);
}
}
/// <summary>
/// Searches for Matches to incomming XLinks, in the local WorkingDirectory
/// </summary>
public void searchForMatchesThread()
{
for (int i = 0; i < matchingObjects.Length; i++)
{
IMarshaller marseller = new JsonMarshaller();
OOClass currentPotentialMatch = marseller.UnmarshallObject<OOClass>(matchingObjects[i].ToString());
Program.directoryBrowser.searchForXLinkMatches(currentPotentialMatch);
}
}
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 void MarshallAndUnMarshallNoExceptionTest()
{
IMarshaller marshaller = new JsonMarshaller();
BeanDescription bean = BeanDescription.createInstance("classname");
RemoteMethodCall remoteMC = RemoteMethodCall.CreateInstance("methodName", new List<Object>() { "Test1" }, new Dictionary<String, String>(), new List<String>() { "Classes" }, new List<String> { "Real" });
MethodCallMessage message = MethodCallMessage.createInstance("principal", bean, remoteMC, "123", false, "TestCase");
String result = marshaller.MarshallObject(message);
MethodCallMessage unmarshalledResult = (MethodCallMessage)marshaller.UnmarshallObject(result, typeof(MethodCallMessage));
MethodCallMessage unmarshalledResultType = marshaller.UnmarshallObject<MethodCallMessage>(result);
Assert.AreNotEqual(unmarshalledResult, unmarshalledResultType);
Assert.IsTrue(result.Contains("[\"Real\"]"));
Assert.IsTrue(result.Contains("[\"Classes\"]"));
Assert.IsTrue(result.Contains("methodName"));
Assert.IsTrue(result.Contains("TestCase"));
Assert.IsTrue(result.Contains("c"));
Assert.IsTrue(result.Contains("\"callId\":\"123\""));
}
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 void TestUploadAndDownloadFile()
{
IEricaChats_FileDTO ericaChats_FileDTO = new EricaChats_FileDTO();
//************************ Test Upload
//Set up the request File DTO and it's contents
byte[] fileBytes = GetEmbeddedResourceAsBytes("TestFiles/TextFile.txt");
string fileBytesAsBase64String = GetBase64StringFromBytes(fileBytes);
ericaChats_FileDTO.FileBytesAsAsBase64String = fileBytesAsBase64String;
ericaChats_FileDTO.FileNameGuid = Guid.NewGuid().ToString();
string payload = JsonMarshaller.Marshall(ericaChats_FileDTO);
//Call the File Manager to perform an upload
HttpResponseMessage uploadResponse = GetFileManagerResponse(payload, "UploadFile", true);
Assert.IsNotNull(uploadResponse);
Assert.IsTrue(uploadResponse.IsSuccessStatusCode);
//************************ Test Download
//Now use the File Guid to Download the file using the File Manager
string endpoint = $"DownloadFile/{ericaChats_FileDTO.FileNameGuid}";
HttpResponseMessage response = GetFileManagerResponse(string.Empty, endpoint);
Assert.IsNotNull(response);
Assert.IsTrue(response.IsSuccessStatusCode);
//Get the content body from the response
string contentBody = GetResponseContentBody(response);
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
//Compare the response File DTO contents to the request File DTO contents. They should be identical.
IEricaChats_FileDTO ericaChats_FileDTO_Downloaded = JsonMarshaller.UnMarshall <EricaChats_FileDTO>(contentBody);
Assert.IsTrue(String.Compare(ericaChats_FileDTO.FileNameGuid, ericaChats_FileDTO_Downloaded.FileNameGuid, StringComparison.CurrentCulture) == 0);
Assert.IsTrue(String.Compare(ericaChats_FileDTO.FileBytesAsAsBase64String, ericaChats_FileDTO_Downloaded.FileBytesAsAsBase64String, StringComparison.CurrentCulture) == 0);
}
public void TestPost()
{
try
{
IEricaMQ_MessageDTO ericaMQ_MessageDTO = new EricaMQ_Message();
ericaMQ_MessageDTO.Context = "UnitTest";
ericaMQ_MessageDTO.Data = "UnitTest";
ericaMQ_MessageDTO.Sender = "UnitTest";
string mqRequest = JsonMarshaller.Marshall(ericaMQ_MessageDTO);
HttpResponseMessage response = GetRequestResponse(mqRequest);
Assert.IsTrue(response.IsSuccessStatusCode);
string contentBody = GetContent(response);
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
IEricaMQ_MessageDTO mqResponse = JsonMarshaller.UnMarshall <EricaMQ_Message>(contentBody);
Assert.IsNotNull(mqResponse);
}
catch (Exception)
{
throw;
}
}
public void TestPut()
{
try
{
//POST
IEricaMQ_MessageDTO ericaMQ_MessageDTO = new EricaMQ_Message();
ericaMQ_MessageDTO.Context = "UnitTest";
ericaMQ_MessageDTO.Data = "UnitTest";
ericaMQ_MessageDTO.Sender = "UnitTest";
string mqRequest = JsonMarshaller.Marshall(ericaMQ_MessageDTO);
HttpResponseMessage response = GetRequestResponse(mqRequest);
Assert.IsTrue(response.IsSuccessStatusCode);
string contentBody = GetContent(response);
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
IEricaMQ_MessageDTO mqResponse = JsonMarshaller.UnMarshall <EricaMQ_Message>(contentBody);
Assert.IsNotNull(mqResponse);
//PUT
string newData = "Love";
mqResponse.Data = newData;
string updatedJsonMqRequest = JsonMarshaller.Marshall(mqResponse);
HttpResponseMessage updatedMqResponseMessage = GetRequestResponse(updatedJsonMqRequest, true);
Assert.IsTrue(updatedMqResponseMessage.IsSuccessStatusCode);
string updatedContentBody = GetContent(updatedMqResponseMessage);
Assert.IsFalse(String.IsNullOrEmpty(updatedContentBody));
IEricaMQ_MessageDTO updatedMqMessage = JsonMarshaller.UnMarshall <EricaMQ_Message>(updatedContentBody);
Assert.IsNotNull(updatedMqMessage);
Assert.AreEqual(newData, updatedMqMessage.Data);
}
catch (Exception)
{
throw;
}
}
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 void TestGetFileMetaDataByChannel()
{
//SetUp: Create some file meta data in the EricaChats Database and make sure each chat message has ChannelID = 1.
//Call the File Manager giving it a valid ChannelId
string endpoint = $"GetFileMetaDataByChannel/1";
HttpResponseMessage metaResponse = GetFileManagerResponse(string.Empty, endpoint);
Assert.IsNotNull(metaResponse);
//Get the content body from the response
string contentBody = GetResponseContentBody(metaResponse);
//Check the response list and UnMarshall it into a List of File DTO objects.
Assert.IsFalse(String.IsNullOrEmpty(contentBody));
List <IEricaChats_MessageDTO> responseList = JsonMarshaller.UnMarshall <List <IEricaChats_MessageDTO> >(contentBody);
//Verify the list
foreach (var fileMetaDTO in responseList)
{
Assert.IsFalse(String.IsNullOrEmpty(fileMetaDTO.FileAttachmentGUID));
Assert.IsFalse(String.IsNullOrEmpty(fileMetaDTO.FriendlyFileName));
}
}
public void UnMarshallExceptionTest()
{
IMarshaller marshaller = new JsonMarshaller();
try
{
marshaller.UnmarshallObject<RemoteMethodCall>("EXCEPTION");
Assert.Fail();
}
catch (BridgeException) { }
try
{
marshaller.UnmarshallObject("EXCEPTION", typeof(RemoteMethodCall));
Assert.Fail();
}
catch (BridgeException) { }
}
private void NotifyConsumers(IEricaMQ_MessageDTO message)
{
try
{
//NOTE: Notify the consumers using the type of the adapter stored on the message if one exists, otherwise just marshall the message
// and send without passing through the adapter.
if (string.IsNullOrEmpty(message.AdapterAssemblyQualifiedName))
{
_hubContext.Clients.Group(Constants_EricaMQ_Hub.GroupName_LatestMessage).SendAsync(Constants_EricaMQ_Hub.ClientEvent_ReceiveLatestMessage, JsonMarshaller.Marshall(message));
}
else
{
//TODO: Divide the Hub client groups into consumer types, i.e. EricaChatsReceiveLatestConsumedMessage. Then use the message.Context to branch and determine
//the Hub Client Group
string consumedMessage = _consumerAdapterFactory.Consume(message);
_hubContext.Clients.Group(Constants_EricaMQ_Hub.GroupName_LatestMessage).SendAsync(Constants_EricaMQ_Hub.ClientEvent_ReceiveLatestConsumedMessage, consumedMessage);
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
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 async Task <string> GetMessagesInRange(DateTime afterThisTimeStamp, int maxAmount, DateTime beforeThisTimeStamp)
{
try
{
var newMessages = GetMessageListInRange(afterThisTimeStamp, maxAmount, beforeThisTimeStamp);
string lastDateRead = string.Empty;
foreach (var message in newMessages)
{
await Clients.Caller.SendAsync(Constants_EricaMQ_Hub.ClientEvent_ReceiveMessagesInRange, JsonMarshaller.Marshall(message));
lastDateRead = message.CreatedDateTime.ToString("yyyy-MM-dd HH:mm:ss.fffffff");
}
return(lastDateRead);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw new ApplicationException(ex.Message, ex);
}
}
