public static XmlDictionaryReader SetupMessageContractTests(bool isWrapped)
{
MyInspector inspector = new MyInspector();
BasicHttpBinding binding = new BasicHttpBinding();
ChannelFactory <IMessageContract> factory = new ChannelFactory <IMessageContract>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic));
factory.Endpoint.EndpointBehaviors.Add(inspector);
IMessageContract clientProxy = factory.CreateChannel();
MessageContractTypes.RequestBankingData transaction = new MessageContractTypes.RequestBankingData();
transaction.accountName = MessageContractConstants.customerElementValue;
transaction.transactionDate = DateTime.Now;
MessageContractConstants.dateElementValue = transaction.transactionDate.TimeOfDay.ToString();
transaction.amount = Convert.ToInt32(MessageContractConstants.transactionElementValue);
if (isWrapped)
{
MessageContractTypes.ReplyBankingData responseData = clientProxy.MessageContractRequestReply(transaction);
}
else
{
MessageContractTypes.ReplyBankingDataNotWrapped responseData = clientProxy.MessageContractRequestReplyNotWrapped(transaction);
}
XmlDictionaryReader reader = inspector.ReceivedMessage.GetReaderAtBodyContents();
return(reader);
}
public void SendMessageContract(IMessageContract contract, bool compress = false, bool encrypt = false, bool close = false)
{
var builder = new SimpleMessage(MessageType.MessageContract, this, Debug)
.CompressMessage(compress)
.EncryptMessage(encrypt)
.SetHeaderString(contract.MessageHeader)
.SetBytes(contract.SerializeToBytes());
builder.Build();
SendToSocket(builder.PayLoad, close, false);
}
private MessageTable CreateNewMessage(IMessageContract messageContract)
{
UserTable user = RetrieveUser(messageContract.UserName);
MessageTable newMessage = new MessageTable
{
MessageText = messageContract.Message,
SenderId = user.Id,
MessageCreated = messageContract.MessageCreated
};
return(newMessage);
}
public object HandleMessage(IMessageContract message)
{
var handler = handlers.FirstOrDefault(m => m.CanHandle(message.MessageType));
if (handler == null)
{
Console.WriteLine($"No handler found for {message.MessageType} messageType");
return(null);
}
return(handler.Handle(message.Data));
}
private void Publish(IMessageContract message, Guid correlationId)
{
var props = channel.CreateBasicProperties();
props.CorrelationId = correlationId.ToString();
props.ReplyTo = responseQueueName;
var body = message.Serialize();
logger.LogInformation($"Sending {message?.MessageType} message with CorrelationId {correlationId}");
channel.BasicPublish(string.Empty, requestQueueName, props, body);
}
private Message CreateNewMessage(IMessageContract messageContract)
{
User user = RetrieveUser(messageContract.UserName);
Message newMessage = new Message
{
MessageText = messageContract.Message,
SenderId = user.Id,
SenderEmailAddress = user.EmailAddress,
MessageCreated = messageContract.MessageCreated
};
return(newMessage);
}
private void ProcessMessageDispatch(IMessageContract messageContract, Message message,
IRepoTransaction repoTransaction)
{
foreach (var emailAddress in messageContract.EmailAccounts)
{
MessageDispatch messageDispatch = new MessageDispatch
{
EmailAddress = emailAddress,
MessageId = message.Id,
MessageReceived = false
};
PersistMessagedispatch(messageDispatch, repoTransaction);
}
}
public async Task SendMessageContractAsync(int id, IMessageContract contract, bool compress = false, bool encrypt = false, bool close = false)
{
var client = GetClient(id);
var builder = new SimpleMessage(MessageType.MessageContract, this, Debug)
.CompressMessage(compress)
.EncryptMessage(encrypt)
.SetHeaderString(contract.MessageHeader)
.SetBytes(contract.SerializeToBytes())
.SetSendClient(client);
await builder.BuildAsync();
SendToSocket(builder.PayLoad, close, false, id);
}
public static MyInspector SetupMessageContractTests(out IMessageContract clientProxy,
out MessageContractTypes.RequestBankingData transaction)
{
MyInspector inspector = new MyInspector();
BasicHttpBinding binding = new BasicHttpBinding();
ChannelFactory<IMessageContract> factory = new ChannelFactory<IMessageContract>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic));
factory.Endpoint.EndpointBehaviors.Add(inspector);
clientProxy = factory.CreateChannel();
transaction = new MessageContractTypes.RequestBankingData();
transaction.accountName = MessageContractConstants.customerElementValue;
transaction.transactionDate = DateTime.Now;
MessageContractConstants.dateElementValue = transaction.transactionDate.TimeOfDay.ToString();
transaction.amount = Convert.ToInt32(MessageContractConstants.transactionElementValue);
return inspector;
}
public static MyInspector SetupMessageContractTests(out IMessageContract clientProxy,
out MessageContractTypes.RequestBankingData transaction)
{
MyInspector inspector = new MyInspector();
BasicHttpBinding binding = new BasicHttpBinding();
ChannelFactory <IMessageContract> factory = new ChannelFactory <IMessageContract>(binding, new EndpointAddress(Endpoints.HttpBaseAddress_Basic));
factory.Endpoint.EndpointBehaviors.Add(inspector);
clientProxy = factory.CreateChannel();
transaction = new MessageContractTypes.RequestBankingData();
transaction.accountName = MessageContractConstants.customerElementValue;
transaction.transactionDate = DateTime.Now;
MessageContractConstants.dateElementValue = transaction.transactionDate.TimeOfDay.ToString();
transaction.amount = Convert.ToInt32(MessageContractConstants.transactionElementValue);
return(inspector);
}
private void CreateMessageTransaction(IMessageContract messageContract,
MessageTable message)
{
List <MessageTransactionTable> messageTransactions = new List <MessageTransactionTable>();
foreach (var emailAddress in messageContract.EmailAccounts)
{
var messageTransaction = new MessageTransactionTable
{
EmailAddress = emailAddress,
MessageId = message.Id,
MessageReceived = false
};
messageTransactions.Add(messageTransaction);
}
PersistMessageTransaction(messageTransactions);
}
private void PublishResponse(IMessageContract responseValue, string correlationId, string responseQueueName)
{
try
{
var body = responseValue.Serialize();
var responseProps = channel.CreateBasicProperties();
responseProps.CorrelationId = correlationId;
channel.BasicPublish(string.Empty, responseQueueName, responseProps, body);
Console.WriteLine($"Sending {responseValue?.MessageType} response with CorrelationId {correlationId}");
}
catch (Exception ex)
{
Console.WriteLine($"Error occurred during sending message with a {correlationId} correlationId - {ex.Message}");
}
}
private void ProcessNewMessage(IMessageContract messageContract, Message message)
{
using (IRepoTransaction repoTransaction = RepoTransactionFactory.GetRepoTransaction(DatabaseOption.DatabaseEngine,
DatabaseOption.DbConnectionString))
{
try
{
repoTransaction.BeginTransaction();
PersistMessage(message, repoTransaction);
ProcessMessageDispatch(messageContract, message, repoTransaction);
repoTransaction.Commit();
}
catch (Exception exception)
{
WriteErrorLog("Unable to process new message request.", exception);
repoTransaction.Callback();
throw;
}
}
}
public MessageRequestTokenContract CreateMessage(IMessageContract message)
{
ValidateAccessToken(message.AccessToken);
if (message.EmailAccounts == null || message.EmailAccounts.Count <= 0)
{
throw new InvalidOperationException("Message contract does not have ant emails attahed.");
}
WriteInfoLog(string.Format("Going to create message. Message content\n{0}", message.Message));
Message newMessage = CreateNewMessage(message);
//PersistMessage(newMessage);
//CreateMessageDispatch(message, newMessage);
ProcessNewMessage(message, newMessage);
//PersistMessageToMongoDbService(newMessage);
return(CreateMessageStateTokenContract(MessageReceivedState.AcknowledgedRequest,
"Message was successfully acknowledged and persisted in our system."));
}
/// <summary>
/// Send a MessageContract to the server
/// <para/>The close parameter indicates if the client should close after sending or not.
/// </summary>
/// <param name="contract"></param>
/// <param name="close"></param>
public void SendMessageContract(IMessageContract contract, bool close)
{
SendMessageContract(contract, false, close);
}
/*=================================
*
* MESSAGECONTRACT
*
*===========================================*/
/// <summary>
/// Send a MessageContract to the server
/// <para/>The close parameter indicates if the client should close after sending or not.
/// </summary>
/// <param name="contract"></param>
/// <param name="encryptContract"></param>
/// <param name="close"></param>
public void SendMessageContract(IMessageContract contract, bool encryptContract, bool close)
{
byte[] data = CreateByteMessageContract(contract, encryptContract);
SendBytes(data, close);
}
public async Task Publish(IMessageContract message)
{
await _activator.Bus.Publish(message);
}
/// <summary>
/// Creates an array of bytes for a MessageContract.
/// </summary>
/// <param name="contract"></param>
/// <param name="encrypt"></param>
/// <returns></returns>
protected byte[] CreateByteMessageContract(IMessageContract contract, bool encrypt)
{
return(CreateByteArray(contract.SerializeToBytes(), "<MC>" + contract.MessageHeader + "</MC>", encrypt));
}
public void SendMessage(IMessageContract message)
{
_view.SendMessage(IMessageAddInAdapter.ContractToViewAdapter(message));
}
/// <summary>
/// Send a message to corresponding client asynchronous.
/// <para/>The close parameter indicates if the client should close after the server has sent a message or not.
/// <para>Id is not zero-based!</para>
/// </summary>
/// <param name="id"></param>
/// <param name="contract"></param>
/// <param name="encryptContract"></param>
/// <param name="close"></param>
public async Task SendMessageContractAsync(int id, IMessageContract contract, bool encryptContract, bool close)
{
await Task.Run(() => SendMessageContract(id, contract, encryptContract, close));
}
/// <summary>
/// Sends a MessageContract to the corresponding client.
/// <para/>The close parameter indicates if the client should close after the server has sent a message or not.
/// <para>This method encrypts the message that will be send.</para>
/// </summary>
/// <param name="id"></param>
/// <param name="contract"></param>
/// <param name="close"></param>
public void SendMessageContract(int id, IMessageContract contract, bool close)
{
SendMessageContract(id, contract, false, true);
}
public MainViewModel(IMessageContract messageContract)
{
_books = new ObservableCollection<Book>(new BooksService().GetAllBooks());
AddBookCommand = new DelegateCommand(OnAddBook);
_messageContract = messageContract;
}
public async Task DeferLocal(TimeSpan delay, IMessageContract message)
{
await _activator.Bus.DeferLocal(delay, message);
}
public MainViewModel(IMessageContract messageContract)
{
_books = new ObservableCollection <Book>(new BooksService().GetAllBooks());
AddBookCommand = new DelegateCommand(OnAddBook);
_messageContract = messageContract;
}
/// <summary>
/// Send a MessageContract to the server asynchronous.
/// <para/>The close parameter indicates if the client should close after sending or not.
/// </summary>
/// <param name="contract"></param>
/// <param name="close"></param>
public async Task SendMessageContractAsync(IMessageContract contract, bool close)
{
await Task.Run(() => SendMessageContract(contract, close));
}
static Network()
{
_contract = new BinaryFormatterMessageContract();
Statistics = new NetworkStatistics();
}
protected internal override void RaiseMessageContractReceived(IClientInfo client, IMessageContract contract, byte[] data)
{
contract.RaiseOnMessageReceived(this, client, contract.DeserializeToObject(data), contract.MessageHeader);
}
