public IChatMessageEnvelope GetNextChatMessage(IChatMessageEnvelope chatMessageEnvelope)
{
try
{
ChatMessage chatMessageInput = this.ChatMessages.FirstOrDefault(msg => msg.ChatMessageID == chatMessageEnvelope.ChatMessageID);
ChatMessage nextChatMessage = this.ChatMessages
.Where(
chat =>
chat.ChannelID == chatMessageInput.ChannelID
&&
chat.CreatedDateTime > chatMessageInput.CreatedDateTime
)
.OrderBy(chat => chat.CreatedDateTime)
.FirstOrDefault();
if (nextChatMessage == null)
{
return(chatMessageEnvelope);//NOTE: They already have the most recent chat message.
}
else
{
this.Entry(nextChatMessage).Reference(nxt => nxt.Channel).Load();
IChatMessageEnvelope nextChatMessageEnvelope = MaptoEnvelope(nextChatMessage);
return(nextChatMessageEnvelope);
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public bool SendServiceRequest(string ClientProxyGUID, string requestEnvelope)
{
lock (_thisLock)
{
try
{
IEnvelope envelope = _marshaller.UnMarshall(requestEnvelope);
int routerIndex = LoadBalanceAlgorithm(_messageBusBankRouters.GetBusKeyCodes().Count);
string routerBusKeyCode = _messageBusBankRouters.GetBusKeyCodes()[routerIndex];
string serviceName = envelope.ServiceRoute;
if (serviceName == ChatServiceNames.GetNextChatMessageService || serviceName == ChatServiceNames.ModifyChatMessageService)
{
IChatMessageEnvelope chatMessageEnvelope = _marshaller.UnMarshall <IChatMessageEnvelope>(requestEnvelope);
chatMessageEnvelope.ServiceRoute = String.Format("{0}.{1}", routerBusKeyCode, serviceName); //NOTE: Salt the route by adding the router.
chatMessageEnvelope.ClientProxyGUID = ClientProxyGUID;
string saltedRequest = _marshaller.MarshallPayloadJSON(chatMessageEnvelope);
_messageBusBankRouters.ResolveMessageBus(routerBusKeyCode).SendMessage(saltedRequest);
return(true);
}
return(false);
}
catch (Exception ex)
{
_log.Error(String.Format("CompositionRoute() - Exception: \n{0}\n{1} \n\n InnerException: \n{2}\n{3}\n\n", ex.Message, ex.StackTrace, ex.InnerException.Message, ex.InnerException.StackTrace));
throw new ApplicationException(ex.Message, ex);
}
}
}
public IEnvelope POST(IEnvelope envelope)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
ChatMessage chatMessageInput = MapToChatMessage((IChatMessageEnvelope)envelope);
if (chatMessageInput.Channel == null)
{
return(SetErrorMessageForInvalidChatChannel((IChatMessageEnvelope)envelope));
}
chatMessageInput.CreatedDateTime = DateTime.Now;
this.ChatMessages.Add(chatMessageInput);
this.SaveChanges();
dbContextTransaction.Commit();
IChatMessageEnvelope recipt = MaptoEnvelope(chatMessageInput);
return(recipt);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public IEnvelope PUT(IEnvelope envelope)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
ChatMessage chatMessageInput = MapToChatMessage((IChatMessageEnvelope)envelope);
if (chatMessageInput.Channel == null)
{
return(SetErrorMessageForInvalidChatChannel((IChatMessageEnvelope)envelope));
}
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();
IChatMessageEnvelope recipt = MaptoEnvelope(updatedChatMessage);
return(recipt);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public string Get(IChatMessageEnvelope request)
{
try
{
if (Tack == null)
{
throw new InvalidOperationException(ExceptionMessage_ITackCannotBeNull);
}
else
{
//NOTE: Define the query
request.Query =
(chatMessageQueryRepo, chatMessageEnvelopeParam) =>
{
IChatMessageEnvelope nextChatMessage = chatMessageQueryRepo.GetLatestChatMessage(chatMessageEnvelopeParam);
return(nextChatMessage);
};
IChatMessageEnvelope responseEnvelope = (IChatMessageEnvelope)Tack.GET(request);
string responseString = _marshaller.MarshallPayloadJSON(responseEnvelope);
return(responseString);
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public List <IEnvelope> GETList(IEnvelope envelope)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
IChatMessageEnvelope chatMessageEnvelope = (IChatMessageEnvelope)envelope;
if (chatMessageEnvelope.QueryForList == null)
{
return new List <IEnvelope> {
envelope
}
}
;
List <IChatMessageEnvelope> results = chatMessageEnvelope.QueryForList(this, chatMessageEnvelope);//NOTE: Avoid large list of if/else statements, let client choose the query
dbContextTransaction.Commit();
return(results.ToList <IEnvelope>());
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public void ProcessMessage(string message)
{
lock (_thisLock)
{
try
{
if (_marshaller == null)
{
throw new InvalidOperationException(ExceptionMessage_MarshallerCannotBeNull);
}
else
{
IChatMessageEnvelope requestEnvelope = _marshaller.UnMarshall <IChatMessageEnvelope>(message);
string responseEnvelope = Get(requestEnvelope);
string ClientProxyGUID = requestEnvelope.ClientProxyGUID;
SendResponse(ClientProxyGUID, responseEnvelope);
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
new ApplicationException(ex.Message, ex);
}
}
}
public IChatMessageEnvelope GetByID(IChatMessageEnvelope request)
{
try
{
if (Tack == null)
{
throw new InvalidOperationException(ExceptionMessage_ITackCannotBeNull);
}
else
{
//NOTE: Define the query
request.Query =
(chatMessageQueryRepo, chatMessageEnvelopeParam) =>
{
IChatMessageEnvelope nextChatMessage = chatMessageQueryRepo.GetChatMessageByID(chatMessageEnvelopeParam);
return(nextChatMessage);
};
return((IChatMessageEnvelope)Tack.GET(request));
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public void TestGetNextChatMessageServiceGET()
{
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IGetNextChatMessageService getNextChatMessageService = _erector.Container.Resolve <IGetNextChatMessageService>();
IMessageBus <string> messageBus = _erector.Container.Resolve <IMessageBus <string> >();
IMessageBusReaderBank <string> messageBusReaderBank = _erector.Container.Resolve <IMessageBusReaderBank <string> >();
messageBusReaderBank.SpecifyTheMessageBus(messageBus);
IMessageBusWriter <string> messageBusWriter = _erector.Container.Resolve <IMessageBusWriter <string> >();
messageBusWriter.SpecifyTheMessageBus(messageBus);
IMessageBusBank <string> messageBusBank = _erector.Container.Resolve <IMessageBusBank <string> >();
messageBusBank.RegisterMessageBus(getNextChatMessageService.ServiceGUID, messageBus);
getNextChatMessageService.MessageBusBank = messageBusBank;
getNextChatMessageService.MessageBusReaderBank = messageBusReaderBank;
getNextChatMessageService.MessageBusReaderBank.AddAnotherReader(getNextChatMessageService.ProcessMessage);
getNextChatMessageService.MessageBusWiter = messageBusWriter;
IChatMessageEnvelope requestEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
requestEnvelope.ChatMessageID = 123;
//Test ITack cannot be null
string tackCannotBeNull;
try
{
tackCannotBeNull = getNextChatMessageService.Get(requestEnvelope);
Assert.Fail();
}
catch (InvalidOperationException ex)
{
string message = ex.Message;
Assert.AreEqual(message, getNextChatMessageService.ExceptionMessage_ITackCannotBeNull);
}
getNextChatMessageService.Tack = GetMockedITack();
requestEnvelope = GetValidChatMessageEnvelope();
requestEnvelope.CreatedDateTime = DateTime.Now;
IChatMessageEnvelope responseEnvelope;
//Read next message
string read = getNextChatMessageService.Get(requestEnvelope);
Assert.IsFalse(String.IsNullOrEmpty(read));
responseEnvelope = marshaller.UnMarshall <IChatMessageEnvelope>(read);
Assert.IsNotNull(responseEnvelope);
Assert.IsTrue(responseEnvelope.ChatMessageID > requestEnvelope.ChatMessageID);
Assert.AreEqual(responseEnvelope.ChatChannelID, requestEnvelope.ChatChannelID);
Assert.IsTrue(DateTime.Compare(responseEnvelope.CreatedDateTime, requestEnvelope.CreatedDateTime) > 0);
}
public void TestServiceFarmLoadBalancerSendServiceRequest()
{
IServiceFarmLoadBalancer serviceFarmLoadBalancer = _erector.Container.Resolve <IServiceFarmLoadBalancer>();
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IChatMessageEnvelope requestEnvelope = GetValidChatMessageEnvelope();
string requestPayload = marshaller.MarshallPayloadJSON(requestEnvelope);
string clientProxyOriginGUID = Guid.NewGuid().ToString();
bool success = serviceFarmLoadBalancer.SendServiceRequest(clientProxyOriginGUID, requestPayload);
Assert.IsTrue(success);
}
public void ProcessMessage(string message)
{
lock (_thisLock)
{
try
{
if (_marshaller == null)
{
throw new InvalidOperationException(ExceptionMessage_MarshallerCannotBeNull);
}
else
{
IChatMessageEnvelope requestEnvelope = _marshaller.UnMarshall <IChatMessageEnvelope>(message);
string ClientProxyGUID = requestEnvelope.ClientProxyGUID;
//NOTE: Get whatever is latest in the data source and send it to the client.
string responseEnvelope = Get(requestEnvelope);
SendResponse(ClientProxyGUID, responseEnvelope);
//NOTE: Now subscribe to skywatch and wait for anything new.
//When it comes in send it to the client proxy and continue.
string responseFromSkyWatch = string.Empty;
Tack.SkyWatch.Watch(typeof(IChatMessageEnvelope).ToString(), ServiceGUID, SkyWatchEventHandler);
//NOTE: Break after poll durration to avoid infinite loop. OS multi-tasking will preempt, but since this service
//can't be invoked directly by the client proxy, I need a way to stop this particular threads loop without envolving the client,
//and without stopping the loops in the other threads by unwatching (they share the same GUID).
DateTime endTime = DateTime.Now.AddMinutes(PollDurrationInMinutes);
while (_skyWatchQueue.IsEmpty)
{
}
while (_skyWatchQueue.IsEmpty == false && DateTime.Compare(DateTime.Now, endTime) < 0)
{
IChatMessageEnvelope chatMessageEnvelopeFromSkyWatch;
if (_skyWatchQueue.TryDequeue(out chatMessageEnvelopeFromSkyWatch))
{
responseFromSkyWatch = _marshaller.MarshallPayloadJSON(chatMessageEnvelopeFromSkyWatch);
SendResponse(ClientProxyGUID, responseFromSkyWatch);
}
}
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
new ApplicationException(ex.Message, ex);
}
}
}
public IChatMessageEnvelope GetChatMessageByID(IChatMessageEnvelope chatMessageEnvelope)
{
try
{
ChatMessage chatMessage = this.ChatMessages.FirstOrDefault(msg => msg.ChatMessageID == chatMessageEnvelope.ChatMessageID);
this.Entry(chatMessage).Reference(chnl => chnl.Channel).Load();
return(MaptoEnvelope(chatMessage));
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public void TestModifyChatMessageServiceSendResponse()
{
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IModifyChatMessageService modifyChatMessageService = _erector.Container.Resolve <IModifyChatMessageService>();
string clientGuid = Guid.NewGuid().ToString();
IMessageBus <string> messageBus_Client = _erector.Container.Resolve <IMessageBus <string> >();
IMessageBus <string> messageBus_Service = _erector.Container.Resolve <IMessageBus <string> >();
messageBus_Client.JsonSchema =
(message) =>
{
//NOTE: Require this schema for the client only since I'm not sending anything to the service.
return(_erector.Container.Resolve <IChatMessageEnvelope>().GetMyJSONSchema());
};
IMessageBusBank <string> messageBusBank = _erector.Container.Resolve <IMessageBusBank <string> >();
messageBusBank.RegisterMessageBus(modifyChatMessageService.ServiceGUID, messageBus_Service);
messageBusBank.RegisterMessageBus(clientGuid, messageBus_Client);
IChatMessageEnvelope requestEnvelope = GetValidChatMessageEnvelope();
string requestPayload = marshaller.MarshallPayloadJSON(requestEnvelope);
bool success = false;
//MessageBusBank cannot be null
try
{
success = modifyChatMessageService.SendResponse(clientGuid, requestPayload);
Assert.Fail();
}
catch (InvalidOperationException ex)
{
string message = ex.Message;
Assert.AreEqual(message, modifyChatMessageService.ExceptionMessage_MessageBusBankCannotBeNull);
}
success = false;
//Client should recieve message in their message bus.
modifyChatMessageService.MessageBusBank = messageBusBank;
success = modifyChatMessageService.SendResponse(clientGuid, requestPayload);
Assert.IsTrue(success);
string clientMessage = messageBus_Client.ReceiveMessage();
Assert.IsFalse(String.IsNullOrEmpty(clientMessage));
Assert.AreEqual(requestPayload, clientMessage);
}
public void TestMapToChatMessage()
{
SQLDataBaseBoardChatMessage sQLDataBaseBoardChatMessage = new SQLDataBaseBoardChatMessage(new SQLDBConfigurationProvider(), new ChatMessageEnvelopeFactory());
IChatMessageEnvelope chatMessageEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
chatMessageEnvelope.ChatMessageID = 236;
chatMessageEnvelope.ChatChannelID = 1;
chatMessageEnvelope.ChatChannelName = "love";
ChatMessage chatMessage = sQLDataBaseBoardChatMessage.MapToChatMessage(chatMessageEnvelope);
Assert.IsNotNull(chatMessage);
Assert.AreEqual(chatMessage.ChatMessageID, chatMessageEnvelope.ChatMessageID);
Assert.AreEqual(chatMessage.ChannelID, chatMessageEnvelope.ChatChannelID);
}
private IChatMessageEnvelope GetValidChatMessageEnvelope()
{
IChatMessageEnvelope chatMessageEnvelope = _erector.Container.Resolve<IChatMessageEnvelope>();
chatMessageEnvelope.ServiceRoute = "ServiceRoute";
chatMessageEnvelope.ClientProxyGUID = Guid.NewGuid().ToString();
chatMessageEnvelope.RequestMethod = "GET";
chatMessageEnvelope.ChatMessageID = 1;
chatMessageEnvelope.ChatChannelID = 1;
chatMessageEnvelope.ChatChannelName = "AwesomeSoft";
chatMessageEnvelope.SenderUserName = "******";
chatMessageEnvelope.ChatMessageBody = "I love you Dionn.";
chatMessageEnvelope.CreatedDateTime = DateTime.MinValue;
chatMessageEnvelope.ModifiedDateTime = DateTime.MinValue;
return chatMessageEnvelope;
}
public void TestRoutingWebServiceGET()
{
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IServiceFarmLoadBalancer serviceFarmLoadBalancer = _erector.Container.Resolve <IServiceFarmLoadBalancer>();
IClientProxy clientProxy = _erector.Container.Resolve <IClientProxy>();
IRoutingWebService routingWebService = new RoutingWebService(default(RequestDelegate));
IChatMessageEnvelope chatMessageEnvelope = GetValidChatMessageEnvelope();
chatMessageEnvelope.ServiceRoute = ChatServiceNames.GetNextChatMessageService;
string requestEnvelope = marshaller.MarshallPayloadJSON(chatMessageEnvelope);
string responseEnvelope = routingWebService.Get(requestEnvelope, serviceFarmLoadBalancer, clientProxy);
Assert.IsFalse(String.IsNullOrEmpty(responseEnvelope));
}
public void TestMaptoEnvelope()
{
SQLDataBaseBoardChatMessage sQLDataBaseBoardChatMessage = new SQLDataBaseBoardChatMessage(new SQLDBConfigurationProvider(), new ChatMessageEnvelopeFactory());
ChatMessage chatMessage = new ChatMessage();
Channel channel = new Channel();
chatMessage.ChannelID = 123;
chatMessage.ChatMessageID = 147;
chatMessage.Channel = channel;
IChatMessageEnvelope chatMessageEnvelope = sQLDataBaseBoardChatMessage.MaptoEnvelope(chatMessage);
Assert.IsNotNull(chatMessageEnvelope);
Assert.AreEqual(chatMessageEnvelope.ChatMessageID, chatMessage.ChatMessageID);
Assert.AreEqual(chatMessageEnvelope.ChatChannelID, chatMessage.ChannelID);
}
public void ProcessMessage(string message)
{
lock (_thisLock)
{
try
{
if (_marshaller == null)
{
throw new InvalidOperationException(ExceptionMessage_MarshallerCannotBeNull);
}
else
{
IChatMessageEnvelope requestEnvelope = _marshaller.UnMarshall <IChatMessageEnvelope>(message);
string responseEnvelope = String.Empty;
string ClientProxyGUID = requestEnvelope.ClientProxyGUID;
if (requestEnvelope.RequestMethod == "POST")
{
responseEnvelope = Post(requestEnvelope);
SendResponse(ClientProxyGUID, responseEnvelope);
}
else if (requestEnvelope.RequestMethod == "PUT")
{
responseEnvelope = Put(requestEnvelope);
SendResponse(ClientProxyGUID, responseEnvelope);
}
else if (requestEnvelope.RequestMethod == "DELETE")
{
responseEnvelope = Delete(requestEnvelope);
SendResponse(ClientProxyGUID, responseEnvelope);
}
else
{
//NOTE: Echo it back.
SendResponse(ClientProxyGUID, message);
}
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
new ApplicationException(ex.Message, ex);
}
}
}
public ChatMessage MapToChatMessage(IChatMessageEnvelope chatMessageEnvelope)
{
try
{
ChatMessage chatMessage = new ChatMessage();
chatMessage.Channel = MapToChannel(chatMessageEnvelope);
chatMessage.ChannelID = chatMessage.Channel.ChannelID;
chatMessage.ChatMessageID = chatMessageEnvelope.ChatMessageID;
chatMessage.ChatMessageBody = chatMessageEnvelope.ChatMessageBody;
return(chatMessage);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public IChatMessageEnvelope MaptoEnvelope(ChatMessage chatMessage)
{
try
{
IChatMessageEnvelope chatMessageEnvelope = _chatMessageEnvelopeFactory.InstantiateIEnvelope();
chatMessageEnvelope.ChatChannelID = chatMessage.ChannelID;
chatMessageEnvelope.ChatChannelName = chatMessage.Channel.ChannelName;
chatMessageEnvelope.ChatMessageID = chatMessage.ChatMessageID;
chatMessageEnvelope.ChatMessageBody = chatMessage.ChatMessageBody;
chatMessageEnvelope.CreatedDateTime = chatMessage.CreatedDateTime;
chatMessageEnvelope.ModifiedDateTime = chatMessage.ModifiedDateTime;
return(chatMessageEnvelope);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
private ITack GetMockedITack()
{
var mockedITack = new Mock <ITack>();
mockedITack
.Setup(tack => tack.GET(It.IsAny <IEnvelope>()))
.Returns <IEnvelope>((arg) =>
{
//NOTE: Return the next chat message on this channel.
IChatMessageEnvelope newEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
newEnvelope.ChatMessageID = ((IChatMessageEnvelope)arg).ChatMessageID + 1;
newEnvelope.ChatChannelID = ((IChatMessageEnvelope)arg).ChatChannelID;
newEnvelope.CreatedDateTime = ((IChatMessageEnvelope)arg).CreatedDateTime.AddMinutes(5);
newEnvelope.ModifiedDateTime = DateTime.MinValue;
return(newEnvelope);
});
return(mockedITack.Object);
}
public void TestValidateMessage()
{
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IEnvelope envelope = _erector.Container.Resolve <IEnvelope>();
IChatMessageEnvelope chatMessagesEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
IMessageBus <string> messageBus = _erector.Container.Resolve <IMessageBus <string> >();
//NOTE: Set up a valid envelope
envelope.ClientProxyGUID = Guid.NewGuid().ToString();
envelope.ServiceRoute = ChatServiceNames.ModifyChatMessageService;
envelope.RequestMethod = "GET";
string message = marshaller.MarshallPayloadJSON(envelope);
bool isValid = messageBus.ValidateMessage(message, envelope.GetMyJSONSchema());
Assert.IsTrue(isValid);
isValid = messageBus.ValidateMessage(message, chatMessagesEnvelope.GetMyJSONSchema());
Assert.IsFalse(isValid);
}
public void TestClientProxyPollMessageBus()
{
IMarshaller marshaller = _erector.Container.Resolve <IMarshaller>();
IClientProxy clientProxy = _erector.Container.Resolve <IClientProxy>();
string clientGuid = Guid.NewGuid().ToString();
IMessageBus <string> messageBus_Client = _erector.Container.Resolve <IMessageBus <string> >();
messageBus_Client.SkipValidation = true;
IMessageBusReaderBank <string> messageBusReaderBank = _erector.Container.Resolve <IMessageBusReaderBank <string> >();
messageBusReaderBank.SpecifyTheMessageBus(messageBus_Client);
//Message bus reader bank cannot be null
try
{
string readerIsNull = clientProxy.PollMessageBus(new System.Threading.CancellationTokenSource());
Assert.Fail();
}
catch (InvalidOperationException ex)
{
string error = ex.Message;
Assert.AreEqual(error, clientProxy.ExceptionMessage_MessageBusReaderBankCannotBeNull);
}
clientProxy.MessageBusReaderBank = messageBusReaderBank;
IChatMessageEnvelope requestEnvelope = GetValidChatMessageEnvelope();
string requestPayload = marshaller.MarshallPayloadJSON(requestEnvelope);
//Send a message
messageBus_Client.SendMessage(requestPayload);
//Poll the client proxy for that message
string message = clientProxy.PollMessageBus(new System.Threading.CancellationTokenSource());
Assert.IsFalse(String.IsNullOrEmpty(message));
Assert.AreEqual(message, requestPayload);
}
private void SkyWatchEventHandler(ISkyWatchEventTypes skyWatchEventType, string eventKey)
{
lock (_thisLock)
{
try
{
if (skyWatchEventType == ISkyWatchEventTypes.WriteOccured)
{
Type envelopeType = Tack.GetIEnvelopeType(eventKey);
long ID = Tack.GetStorageID(eventKey);
IChatMessageEnvelope eventSubject_ChatMessageEnvelope = _chatMessageEnvelopeFactory.InstantiateIEnvelope();
eventSubject_ChatMessageEnvelope.ChatMessageID = ID;
IChatMessageEnvelope chatMessageEnvelopeFromSkyWatch = GetByID(eventSubject_ChatMessageEnvelope);
_skyWatchQueue.Enqueue(chatMessageEnvelopeFromSkyWatch);
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
}
public IChatMessageEnvelope GetLatestChatMessage(IChatMessageEnvelope chatMessageEnvelope)
{
try
{
ChatMessage chatMessageInput = MapToChatMessage(chatMessageEnvelope);
ChatMessage latestChatMessage = this.ChatMessages
.Where(
chat =>
chat.ChannelID == chatMessageInput.ChannelID
)
.OrderBy(chat => chat.CreatedDateTime)
.FirstOrDefault();
this.Entry(latestChatMessage).Reference(nxt => nxt.Channel).Load();
IChatMessageEnvelope nextChatMessageEnvelope = MaptoEnvelope(latestChatMessage);
return(nextChatMessageEnvelope);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public void TestSQLDataBaseBoardCRUD()
{
SQLDataBaseBoardChatMessage sQLDataBaseBoardChatMessage = new SQLDataBaseBoardChatMessage(new SQLDBConfigurationProvider(), new ChatMessageEnvelopeFactory());
IChatMessageEnvelope chatMessageEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
chatMessageEnvelope.ChatChannelName = "love";
chatMessageEnvelope.ChatChannelID = 1;
chatMessageEnvelope.ChatMessageBody = "Jesus Loves You.";
//Create
IChatMessageEnvelope newChatMessageEnvelope = (IChatMessageEnvelope)sQLDataBaseBoardChatMessage.POST(chatMessageEnvelope);
Assert.IsNotNull(newChatMessageEnvelope);
Assert.IsNotNull(newChatMessageEnvelope.CreatedDateTime);
newChatMessageEnvelope.Query = (queryRepo, envelope) =>
{
return(queryRepo.GetChatMessageByID(envelope));
};
//Read
IChatMessageEnvelope readChatMessageEnvelope = (IChatMessageEnvelope)sQLDataBaseBoardChatMessage.GET(newChatMessageEnvelope);
Assert.IsNotNull(readChatMessageEnvelope);
Assert.AreEqual(readChatMessageEnvelope.ChatMessageID, newChatMessageEnvelope.ChatMessageID);
//Update
IChatMessageEnvelope updateChatMessageEnvelope = (IChatMessageEnvelope)sQLDataBaseBoardChatMessage.PUT(readChatMessageEnvelope);
Assert.IsNotNull(updateChatMessageEnvelope);
Assert.IsTrue(DateTime.Compare(readChatMessageEnvelope.ModifiedDateTime, updateChatMessageEnvelope.ModifiedDateTime) < 0);
//Delete
IChatMessageEnvelope deletedChatMessageEnvelope = (IChatMessageEnvelope)sQLDataBaseBoardChatMessage.DELETE(updateChatMessageEnvelope);
Assert.IsNotNull(updateChatMessageEnvelope);
Assert.IsTrue(DateTime.Compare(updateChatMessageEnvelope.ModifiedDateTime, deletedChatMessageEnvelope.ModifiedDateTime) < 0);
}
public IEnvelope GET(IEnvelope envelope)
{
using (var dbContextTransaction = this.Database.BeginTransaction())
{
try
{
IChatMessageEnvelope chatMessageEnvelope = (IChatMessageEnvelope)envelope;
if (chatMessageEnvelope.Query == null)
{
return(envelope);
}
IChatMessageEnvelope recipt = chatMessageEnvelope.Query(this, chatMessageEnvelope);//NOTE: Avoid large list of if/else statements, let client choose the query
dbContextTransaction.Commit();
return(recipt);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw new ApplicationException(ex.Message, ex);
}
}
}
public string Delete(IChatMessageEnvelope request)
{
try
{
if (Tack == null)
{
throw new InvalidOperationException(ExceptionMessage_ITackCannotBeNull);
}
else
{
IChatMessageEnvelope responseEnvelope = (IChatMessageEnvelope)Tack.DELETE(request);
string responseString = _marshaller.MarshallPayloadJSON(responseEnvelope);
return(responseString);
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
private ITack GetMockedITack()
{
var mockedITack = new Mock <ITack>();
mockedITack
.Setup(tack => tack.POST(It.IsAny <IEnvelope>()))
.Returns <IEnvelope>((arg) =>
{
IChatMessageEnvelope newEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
newEnvelope.ChatMessageID = ((IChatMessageEnvelope)arg).ChatMessageID;
newEnvelope.CreatedDateTime = DateTime.Now;
newEnvelope.ModifiedDateTime = ((IChatMessageEnvelope)arg).ModifiedDateTime;
return(newEnvelope);
});
mockedITack
.Setup(tack => tack.PUT(It.IsAny <IEnvelope>()))
.Returns <IEnvelope>((arg) =>
{
IChatMessageEnvelope newEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
newEnvelope.ChatMessageID = ((IChatMessageEnvelope)arg).ChatMessageID;
newEnvelope.CreatedDateTime = ((IChatMessageEnvelope)arg).CreatedDateTime;
newEnvelope.ModifiedDateTime = DateTime.Now;
return(newEnvelope);
});
mockedITack
.Setup(tack => tack.DELETE(It.IsAny <IEnvelope>()))
.Returns <IEnvelope>((arg) =>
{
IChatMessageEnvelope newEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
newEnvelope.ChatMessageID = ((IChatMessageEnvelope)arg).ChatMessageID;
newEnvelope.CreatedDateTime = ((IChatMessageEnvelope)arg).CreatedDateTime;
newEnvelope.ModifiedDateTime = DateTime.Now;
return(newEnvelope);
});
return(mockedITack.Object);
}
public Channel MapToChannel(IChatMessageEnvelope chatMessageEnvelope)
{
try
{
Channel channel = new Channel();
if (chatMessageEnvelope.ChatChannelID > 0)
{
channel = this.Channels.Find(chatMessageEnvelope.ChatChannelID);
}
else if (String.IsNullOrEmpty(chatMessageEnvelope.ChatChannelName) == false)
{
channel = this.Channels.FirstOrDefault(chnl => chnl.ChannelName == chatMessageEnvelope.ChatChannelName);
}
else
{
channel = null;
}
return(channel);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
