private async Task OnMessageQueueReceived(MessageQueueItem mqi)
{
_logger.LogInformation($"{Name}: Message Queue Received with a message id of {mqi.Message.MessageId}, starting processing...");
await BroadcastMessageLogic.ProcessMessageQueueItem(mqi);
_logger.LogInformation($"{Name}: Finished processing of message {mqi.Message.MessageId}.");
}
public async Task <bool> Process(MessageQueueItem item)
{
bool success = true;
if (Config.SystemBehaviorConfig.IsAzure)
{
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
// Register the function that will process messages
_client.RegisterMessageHandler(ProcessQueueMessage, messageHandlerOptions);
//await ProcessQueueMessage(_client.ReceiveAsync());
}
else
{
return(await ProcessMessageQueueItem(item));
}
_queueService = null;
return(false);
}
public DataBusMsg(MessageQueueItem item)
{
Payload = JsonConvert.DeserializeObject <T>(item.Publication.Payload);
DateCreated = item.Publication.DateCreated;
MaxAttempts = item.Subscription.MaxAttempts;
RetryDelay = item.Subscription.RetryDelay;
LastAttempt = item.LastAttempt;
}
/// <summary>
/// Publishes a message to all subscribers of that type of message.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message">The message that is broadcast.</param>
public void Publish <T>(T message)
{
var messageQueue = new MessageQueueItem <T>()
{
Message = message, Type = typeof(T)
};
_messageQueue.Add(messageQueue);
}
static void PostThreadMessage(Command cmd, Action act)
{
lock (s_thread_msg_queue)
{
MessageQueueItem item = new MessageQueueItem();
item.cmd = cmd;
item.action = act;
s_thread_msg_queue.Enqueue(item);
}
s_queue_event.Set();
}
public void EnqueueMessage(MessageQueueItem messageQueue)
{
if (SystemBehaviorConfig.ServiceBusType == ServiceBusTypes.Rabbit)
{
_rabbitOutboundQueueProvider.EnqueueMessage(messageQueue);
return;
}
VerifyAndCreateClients();
string serializedObject = String.Empty;
if (messageQueue != null && messageQueue.Message != null && messageQueue.MessageId == 0 && messageQueue.Message.MessageId != 0)
{
messageQueue.MessageId = messageQueue.Message.MessageId;
}
try
{
serializedObject = ObjectSerialization.Serialize(messageQueue);
// We are limited to 256KB in azure queue messages
var size = ASCIIEncoding.Unicode.GetByteCount(serializedObject);
if (size > 220000)
{
messageQueue.Profiles = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
if (ASCIIEncoding.Unicode.GetByteCount(serializedObject) > 220000)
{
messageQueue.Message.MessageRecipients = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
}
catch { }
// If we get an Exception, i.e. OutOfMemmory, lets just strip out the heavy data and try.
if (String.IsNullOrWhiteSpace(serializedObject))
{
messageQueue.Profiles = null;
messageQueue.Message.MessageRecipients = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
BrokeredMessage message = new BrokeredMessage(serializedObject);
message.MessageId = string.Format("{0}|{1}", messageQueue.Message.MessageId, messageQueue.Message.ReceivingUserId);
SendMessage(_messageClient, message);
}
public void Process(MessageQueueItem item)
{
bool success = true;
if (Config.SystemBehaviorConfig.IsAzure)
{
ProcessQueueMessage(_client.Receive());
}
else
{
ProcessMessageQueueItem(item);
}
_queueService = null;
}
static void ThreadProc()
{
Debug.Log("rttp working thread running");
long last_input_tick = Utility.GetMilliSecondSinceEpoch();
while (true)
{
long now = Utility.GetMilliSecondSinceEpoch();
long interval = now - last_input_tick;
if (interval > 10 || interval < 0 /*in case clock back*/)
{
rttp.rt_tick();
last_input_tick = now;
}
MessageQueueItem item = new MessageQueueItem();
bool found_item = false;
lock (s_thread_msg_queue)
{
if (s_thread_msg_queue.Count > 0)
{
item = s_thread_msg_queue.Dequeue();
found_item = true;
}
}
if (found_item)
{
if (item.cmd == Command.EXIT)
{
break;
}
else
{
item.action();
continue;
}
}
else
{
s_queue_event.WaitOne(10);
}
}
Debug.Log("rttp working thread exit");
}
public async Task <bool> EnqueueMessageBroadcastAsync(MessageQueueItem mqi, CancellationToken cancellationToken = default(CancellationToken))
{
if (Config.SystemBehaviorConfig.IsAzure)
{
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
var dm = await _departmentsService.GetDepartmentMemberAsync(mqi.Message.ReceivingUserId, mqi.DepartmentId);
string departmentNumber = await _departmentSettingsService.GetTextToCallNumberForDepartmentAsync(dm.DepartmentId);
mqi.DepartmentTextNumber = departmentNumber;
if (mqi.Message.ReceivingUser == null)
{
var user = mqi.Profiles.FirstOrDefault(x => x.UserId == mqi.Message.ReceivingUserId);
if (user != null && user.User != null)
{
mqi.Message.ReceivingUser = user.User;
}
}
}
else if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId))
{
var dm = await _departmentsService.GetDepartmentMemberAsync(mqi.Message.SendingUserId, mqi.DepartmentId);
string departmentNumber = await _departmentSettingsService.GetTextToCallNumberForDepartmentAsync(dm.DepartmentId);
mqi.DepartmentTextNumber = departmentNumber;
}
return(await _outboundQueueProvider.EnqueueMessage(mqi));
}
else
{
QueueItem item = new QueueItem();
item.QueueType = (int)QueueTypes.MessageBroadcast;
item.SourceId = mqi.Message.MessageId.ToString();
item.QueuedOn = DateTime.UtcNow;
await _queueItemsRepository.SaveOrUpdateAsync(item, cancellationToken);
}
return(true);
}
public void EnqueueMessageBroadcast(MessageQueueItem mqi)
{
if (Config.SystemBehaviorConfig.IsAzure)
{
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
var dm = _departmentsService.GetDepartmentMember(mqi.Message.ReceivingUserId, mqi.DepartmentId);
string departmentNumber = _departmentSettingsService.GetTextToCallNumberForDepartment(dm.DepartmentId);
mqi.DepartmentTextNumber = departmentNumber;
if (mqi.Message.ReceivingUser == null)
{
var user = mqi.Profiles.FirstOrDefault(x => x.UserId == mqi.Message.ReceivingUserId);
if (user != null && user.User != null)
{
mqi.Message.ReceivingUser = user.User;
}
}
}
else if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId))
{
var dm = _departmentsService.GetDepartmentMember(mqi.Message.SendingUserId, mqi.DepartmentId);
string departmentNumber = _departmentSettingsService.GetTextToCallNumberForDepartment(dm.DepartmentId);
mqi.DepartmentTextNumber = departmentNumber;
}
_outboundQueueProvider.EnqueueMessage(mqi);
}
else
{
QueueItem item = new QueueItem();
item.QueueType = (int)QueueTypes.MessageBroadcast;
item.SourceId = mqi.Message.MessageId.ToString();
item.QueuedOn = DateTime.UtcNow;
_queueItemsRepository.SaveOrUpdate(item);
}
}
public void EnqueueMessage(MessageQueueItem messageQueue)
{
string serializedObject = String.Empty;
if (messageQueue != null && messageQueue.Message != null && messageQueue.MessageId == 0 && messageQueue.Message.MessageId != 0)
{
messageQueue.MessageId = messageQueue.Message.MessageId;
}
try
{
serializedObject = ObjectSerialization.Serialize(messageQueue);
// We are limited to 256KB in azure queue messages
var size = ASCIIEncoding.Unicode.GetByteCount(serializedObject);
if (size > 220000)
{
messageQueue.Profiles = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
if (ASCIIEncoding.Unicode.GetByteCount(serializedObject) > 220000)
{
messageQueue.Message.MessageRecipients = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
}
catch { }
// If we get an Exception, i.e. OutOfMemmory, lets just strip out the heavy data and try.
if (String.IsNullOrWhiteSpace(serializedObject))
{
messageQueue.Profiles = null;
messageQueue.Message.MessageRecipients = null;
serializedObject = ObjectSerialization.Serialize(messageQueue);
}
SendMessage(ServiceBusConfig.MessageBroadcastQueueName, serializedObject);
}
public void Enqueue(MessageQueueItem item)
{
throw new NotImplementedException();
}
public async Task <bool> SendMessageAsync(Message message, string sendersName, int departmentId, bool broadcastSingle = true, CancellationToken cancellationToken = default(CancellationToken))
{
if (broadcastSingle)
{
foreach (var recip in message.GetRecipients())
{
var m = new Message();
m.Subject = message.Subject;
m.Body = message.Body;
m.SendingUserId = message.SendingUserId;
m.ReceivingUserId = recip;
m.SentOn = message.SentOn;
var savedMessage = await SaveMessageAsync(m, cancellationToken);
var mqi = new MessageQueueItem();
mqi.Message = savedMessage;
var users = new List <string>();
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
users.Add(mqi.Message.ReceivingUserId);
}
if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId))
{
users.Add(mqi.Message.SendingUserId);
}
mqi.Profiles = await _userProfileService.GetSelectedUserProfilesAsync(users);
mqi.DepartmentId = departmentId;
await _queueService.EnqueueMessageBroadcastAsync(mqi, cancellationToken);
}
}
else
{
var mqi = new MessageQueueItem();
mqi.Message = message;
var users = new List <string>();
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
users.Add(mqi.Message.ReceivingUserId);
}
users.AddRange(message.GetRecipients());
if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId) && mqi.Message.SendingUserId != mqi.Message.ReceivingUserId)
{
users.Add(mqi.Message.SendingUserId);
}
mqi.Profiles = await _userProfileService.GetSelectedUserProfilesAsync(users);
mqi.DepartmentId = departmentId;
mqi.MessageId = message.MessageId;
await _queueService.EnqueueMessageBroadcastAsync(mqi, cancellationToken);
}
return(true);
}
public CreateMessageQueueItemCommand(MessageQueueItem item)
{
_item = item;
_item.id = Guid.NewGuid();
}
public static Tuple <bool, string> ProcessQueueMessage(BrokeredMessage message)
{
bool success = true;
string result = "";
if (message != null)
{
MessageQueueItem mqi = null;
try
{
var body = message.GetBody <string>();
if (!String.IsNullOrWhiteSpace(body))
{
try
{
mqi = ObjectSerialization.Deserialize <MessageQueueItem>(body);
}
catch (Exception ex)
{
success = false;
result = "Unable to parse message body Exception: " + ex.ToString();
message.Complete();
}
ProcessMessageQueueItem(mqi);
}
try
{
if (success)
{
message.Complete();
}
}
catch (MessageLockLostException)
{
}
}
catch (Exception ex)
{
result = ex.ToString();
if (mqi != null)
{
ex.Data.Add("DepartmentId", mqi.DepartmentId);
if (mqi.Message != null)
{
ex.Data.Add("MessageId", mqi.Message.MessageId);
ex.Data.Add("SendingUserId", mqi.Message.SendingUserId);
ex.Data.Add("RecievingUserId", mqi.Message.ReceivingUserId);
}
}
ex.Data.Add("MQI", JsonConvert.SerializeObject(mqi));
Logging.LogException(ex);
message.Abandon();
}
}
return(new Tuple <bool, string>(success, result));
}
public void SendMessage(Message message, string sendersName, int departmentId, bool broadcastSingle = true)
{
if (broadcastSingle)
{
foreach (var recip in message.GetRecipients())
{
var m = new Message();
m.Subject = message.Subject;
m.Body = message.Body;
m.SendingUserId = message.SendingUserId;
m.ReceivingUserId = recip;
m.SentOn = message.SentOn;
var savedMessage = SaveMessage(m);
var mqi = new MessageQueueItem();
mqi.Message = savedMessage;
var users = new List <string>();
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
users.Add(mqi.Message.ReceivingUserId);
}
if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId))
{
users.Add(mqi.Message.SendingUserId);
}
mqi.Profiles = _userProfileService.GetSelectedUserProfiles(users);
mqi.DepartmentId = departmentId;
_queueService.EnqueueMessageBroadcast(mqi);
}
}
else
{
var mqi = new MessageQueueItem();
mqi.Message = message;
var users = new List <string>();
if (!String.IsNullOrWhiteSpace(mqi.Message.ReceivingUserId))
{
users.Add(mqi.Message.ReceivingUserId);
}
users.AddRange(message.GetRecipients());
if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId) && mqi.Message.SendingUserId != mqi.Message.ReceivingUserId)
{
users.Add(mqi.Message.SendingUserId);
}
mqi.Profiles = _userProfileService.GetSelectedUserProfiles(users);
mqi.DepartmentId = departmentId;
mqi.MessageId = message.MessageId;
_queueService.EnqueueMessageBroadcast(mqi);
}
}
public static void ProcessMessageQueueItem(MessageQueueItem mqi)
{
var _communicationService = Bootstrapper.GetKernel().Resolve <ICommunicationService>();
if (mqi != null && mqi.Message == null && mqi.MessageId != 0)
{
var messageService = Bootstrapper.GetKernel().Resolve <IMessageService>();
mqi.Message = messageService.GetMessageById(mqi.MessageId);
}
if (mqi != null && mqi.Message != null)
{
if (mqi.Message.MessageRecipients == null || mqi.Message.MessageRecipients.Count <= 0)
{
var messageService = Bootstrapper.GetKernel().Resolve <IMessageService>();
mqi.Message = messageService.GetMessageById(mqi.Message.MessageId);
}
// If we didn't get any profiles chances are the message size was too big for Azure, get selected profiles now.
if (mqi.Profiles == null)
{
var userProfileService = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
if (mqi.Message.MessageRecipients != null && mqi.Message.MessageRecipients.Any())
{
mqi.Profiles = userProfileService.GetSelectedUserProfiles(mqi.Message.MessageRecipients.Select(x => x.UserId).ToList());
}
else
{
mqi.Profiles = userProfileService.GetAllProfilesForDepartment(mqi.DepartmentId).Select(x => x.Value).ToList();
}
}
string name = string.Empty;
if (!String.IsNullOrWhiteSpace(mqi.Message.SendingUserId))
{
var profile = mqi.Profiles.FirstOrDefault(x => x.UserId == mqi.Message.SendingUserId);
if (profile != null)
{
name = profile.FullName.AsFirstNameLastName;
}
}
if (mqi.Message.ReceivingUserId != null && (mqi.Message.Recipients == null || !mqi.Message.Recipients.Any()))
{
if (mqi.Profiles != null)
{
var sendingToProfile = mqi.Profiles.FirstOrDefault(x => x.UserId == mqi.Message.ReceivingUserId);
if (sendingToProfile != null)
{
_communicationService.SendMessage(mqi.Message, name, mqi.DepartmentTextNumber, mqi.DepartmentId, sendingToProfile);
}
else
{
var userProfileService = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
var sender = userProfileService.GetProfileByUserId(mqi.Message.SendingUserId);
if (sender != null)
{
name = sender.FullName.AsFirstNameLastName;
}
}
}
}
else if (mqi.Message.MessageRecipients != null && mqi.Message.MessageRecipients.Any())
{
foreach (var recipient in mqi.Message.MessageRecipients)
{
var sendingToProfile = mqi.Profiles.FirstOrDefault(x => x.UserId == recipient.UserId);
mqi.Message.ReceivingUserId = recipient.UserId;
if (sendingToProfile != null)
{
_communicationService.SendMessage(mqi.Message, name, mqi.DepartmentTextNumber, mqi.DepartmentId, sendingToProfile);
}
}
}
}
_communicationService = null;
}
private async Task StartMonitoring()
{
if (SystemBehaviorConfig.ServiceBusType == ServiceBusTypes.Rabbit)
{
var callQueueReceivedConsumer = new EventingBasicConsumer(_channel);
callQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
CallQueueItem cqi = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
cqi = ObjectSerialization.Deserialize <CallQueueItem>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (cqi != null)
{
if (CallQueueReceived != null)
{
await CallQueueReceived.Invoke(cqi);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicNack(ea.DeliveryTag, false, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var messageQueueReceivedConsumer = new EventingBasicConsumer(_channel);
messageQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
MessageQueueItem mqi = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
mqi = ObjectSerialization.Deserialize <MessageQueueItem>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (mqi != null)
{
if (MessageQueueReceived != null)
{
await MessageQueueReceived.Invoke(mqi);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var distributionListQueueReceivedConsumer = new EventingBasicConsumer(_channel);
distributionListQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
DistributionListQueueItem dlqi = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
dlqi = ObjectSerialization.Deserialize <DistributionListQueueItem>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (dlqi != null)
{
if (DistributionListQueueReceived != null)
{
await DistributionListQueueReceived.Invoke(dlqi);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var notificationQueueReceivedConsumer = new EventingBasicConsumer(_channel);
notificationQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
NotificationItem ni = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
ni = ObjectSerialization.Deserialize <NotificationItem>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (ni != null)
{
if (NotificationQueueReceived != null)
{
await NotificationQueueReceived.Invoke(ni);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var shiftNotificationQueueReceivedConsumer = new EventingBasicConsumer(_channel);
shiftNotificationQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
ShiftQueueItem sqi = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
sqi = ObjectSerialization.Deserialize <ShiftQueueItem>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (sqi != null)
{
if (ShiftNotificationQueueReceived != null)
{
await ShiftNotificationQueueReceived.Invoke(sqi);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var cqrsEventQueueReceivedConsumer = new EventingBasicConsumer(_channel);
cqrsEventQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
CqrsEvent cqrs = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
cqrs = ObjectSerialization.Deserialize <CqrsEvent>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (cqrs != null)
{
if (CqrsEventQueueReceived != null)
{
await CqrsEventQueueReceived.Invoke(cqrs);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
var paymentEventQueueReceivedConsumer = new EventingBasicConsumer(_channel);
paymentEventQueueReceivedConsumer.Received += async(model, ea) =>
{
if (ea != null && ea.Body.Length > 0)
{
CqrsEvent cqrs = null;
try
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
cqrs = ObjectSerialization.Deserialize <CqrsEvent>(message);
}
catch (Exception ex)
{
_channel.BasicNack(ea.DeliveryTag, false, false);
Logging.LogException(ex, Encoding.UTF8.GetString(ea.Body.ToArray()));
}
try
{
if (cqrs != null)
{
if (PaymentEventQueueReceived != null)
{
await PaymentEventQueueReceived.Invoke(cqrs);
_channel.BasicAck(ea.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Logging.LogException(ex);
if (RetryQueueItem(ea, ex))
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
}
};
String callQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.CallBroadcastQueueName),
autoAck: false,
consumer: callQueueReceivedConsumer);
String messageQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.MessageBroadcastQueueName),
autoAck: false,
consumer: messageQueueReceivedConsumer);
String distributionListQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.EmailBroadcastQueueName),
autoAck: false,
consumer: distributionListQueueReceivedConsumer);
String notificationQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.NotificaitonBroadcastQueueName),
autoAck: false,
consumer: notificationQueueReceivedConsumer);
String shiftNotificationQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.ShiftNotificationsQueueName),
autoAck: false,
consumer: shiftNotificationQueueReceivedConsumer);
String cqrsEventQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.SystemQueueName),
autoAck: false,
consumer: cqrsEventQueueReceivedConsumer);
String paymentEventQueueReceivedConsumerTag = _channel.BasicConsume(
queue: SetQueueNameForEnv(ServiceBusConfig.PaymentQueueName),
autoAck: false,
consumer: paymentEventQueueReceivedConsumer);
}
}
public async Task <Tuple <bool, string> > ProcessQueueMessage(Message message, CancellationToken token)
{
bool success = true;
string result = "";
if (message != null)
{
MessageQueueItem mqi = null;
try
{
var body = message.GetBody <string>();
if (!String.IsNullOrWhiteSpace(body))
{
try
{
mqi = ObjectSerialization.Deserialize <MessageQueueItem>(body);
}
catch (Exception ex)
{
success = false;
result = "Unable to parse message body Exception: " + ex.ToString();
//message.Complete();
await _client.CompleteAsync(message.SystemProperties.LockToken);
}
await ProcessMessageQueueItem(mqi);
}
try
{
if (success)
{
await _client.CompleteAsync(message.SystemProperties.LockToken);
}
//message.Complete();
}
catch (MessageLockLostException)
{
}
}
catch (Exception ex)
{
result = ex.ToString();
if (mqi != null)
{
ex.Data.Add("DepartmentId", mqi.DepartmentId);
if (mqi.Message != null)
{
ex.Data.Add("MessageId", mqi.Message.MessageId);
ex.Data.Add("SendingUserId", mqi.Message.SendingUserId);
ex.Data.Add("RecievingUserId", mqi.Message.ReceivingUserId);
}
}
ex.Data.Add("MQI", JsonConvert.SerializeObject(mqi));
Logging.LogException(ex);
await _client.AbandonAsync(message.SystemProperties.LockToken);
//message.Abandon();
}
}
return(new Tuple <bool, string>(success, result));
}
