static void Main(string[] args)
{
try
{
var converter = new MessageConverter();
Console.WriteLine("Alexandria Echo");
var input = Console.In.ReadToEnd();
var message = converter.DeserializeFromJson<Message>(input);
Console.WriteLine("Message Received");
Console.WriteLine("Type: {0}", message.Type);
Console.WriteLine("Header: {0}", message.Header);
Console.WriteLine("Body: {0}", message.Body);
//Console.WriteLine("Press Enter to close");
//Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine("Message Error: " + ex.Message);
}
}
public async Task<Response> ExecuteRequest(Request request)
{
if (!_tcpClient.Connected)
{
throw new InvalidOperationException("Connect first.");
}
var converter = new MessageConverter();
var requestBuffer = new MemoryStream();
var streamWriter = new HmBinaryMessageWriter(requestBuffer);
var requestReader = new MessageReader(request);
converter.Convert(requestReader, streamWriter);
var networkStream = _tcpClient.GetStream();
requestBuffer.Position = 0;
await requestBuffer.CopyToAsync(networkStream);
await Task.Delay(100);
//todo: implement buffered reader
var streamReader = new HmBinaryMessageReader(networkStream);
var responseBuilder = new MessageBuilder();
converter.Convert(streamReader, responseBuilder);
var response = (Response)responseBuilder.Result;
return response;
}
public void ConvertNullSDKToSDK()
{
sdkMessage1 = null;
converter = new MessageConverter(sdkMessage1);
Assert.IsNull(converter.ToSDKMessage());
}
public void ConvertNullAPIToAPI()
{
apiMessage1 = null;
converter = new MessageConverter(apiMessage1);
Assert.IsNull(converter.ToAPIMessage());
}
static void Main(string[] args)
{
var converter = new MessageConverter();
var body = "Hello Alexandria";
if (args != null && args.Length > 0)
{
if (!string.IsNullOrEmpty(args[0]))
{
body = args[0];
}
}
var message = new Message() { Type = MessageType.Json, Header = "Test Message", Body = body };
var output = converter.SeralizeToJson(message);
Console.WriteLine(output);
}
public Task HandleRequest(IRequestContext requestContext)
{
var converter = new MessageConverter();
var messageBuilder = new MessageBuilder();
converter.Convert(requestContext.Request, messageBuilder);
var request = (Request)messageBuilder.Result;
var response = HandleRequest(request);
#if DEBUG
System.Diagnostics.Debug.WriteLine(messageBuilder.Debug);
Console.WriteLine(request);
#endif
var responseReader = new MessageReader(response);
converter.Convert(responseReader, requestContext.Response);
return Task.FromResult(0);
}
public async Task <List <MessageDto> > SearchMessagesAsync(
string query,
ConversationType?conversationType,
long?conversationId,
ConversationType?navConversationType,
long?navConversationId,
Guid?navMessageId,
long?userId,
int limit = 30)
{
using (MessengerDbContext context = contextFactory.Create())
{
var messagesCondition = PredicateBuilder.New <Message>();
var messagesQuery = context.Messages.AsNoTracking();
ExpressionsHelper expressionsHelper = new ExpressionsHelper();
var messageExpression = expressionsHelper.GetMessageExpression(query);
if (conversationType != null && conversationId != null)
{
if (userId != null && !await conversationsService.IsUserInConversationAsync(conversationType.Value, conversationId.Value, userId.Value).ConfigureAwait(false))
{
return(new List <MessageDto>());
}
switch (conversationType.Value)
{
case ConversationType.Dialog:
messagesQuery = messagesQuery.Where(message => message.DialogId == conversationId);
break;
case ConversationType.Chat:
messagesQuery = messagesQuery.Where(message => message.ChatId == conversationId);
break;
case ConversationType.Channel:
messagesQuery = messagesQuery.Where(message => message.ChannelId == conversationId);
break;
}
}
else
{
if (userId != null)
{
var dialogsIds = await loadDialogsService.GetUserDialogsIdAsync(userId.Value).ConfigureAwait(false);
var chatsIds = await loadChatsService.GetUserChatsIdAsync(userId.Value).ConfigureAwait(false);
var channelsIds = await loadChannelsService.GetUserChannelsIdAsync(userId.Value).ConfigureAwait(false);
messagesCondition = dialogsIds.Aggregate(messagesCondition,
(current, value) => current.Or(option => option.DialogId == value).Expand());
messagesCondition = chatsIds.Aggregate(messagesCondition,
(current, value) => current.Or(option => option.ChatId == value).Expand());
messagesCondition = channelsIds.Aggregate(messagesCondition,
(current, value) => current.Or(option => option.ChannelId == value).Expand());
messagesQuery = messagesQuery.Where(messagesCondition);
}
}
if (navConversationId != null && navConversationType != null && navMessageId != null)
{
var navMessage = (await GetMessagesByIdAsync(
new List <Guid> {
navMessageId.Value
},
navConversationType.Value,
navConversationId.Value,
userId).ConfigureAwait(false)).FirstOrDefault();
if (navMessage != null)
{
messagesQuery = messagesQuery
.Where(message => message.SendingTime <= navMessage.SendingTime && message.GlobalId != navMessage.GlobalId);
}
}
var messages = await messagesQuery
.Where(messageExpression)
.Where(message => !message.Deleted && (message.ExpiredAt == null || message.ExpiredAt > DateTime.UtcNow.ToUnixTime()))
.OrderByDescending(message => message.SendingTime)
.Take(limit)
.Include(message => message.Attachments)
.ToListAsync()
.ConfigureAwait(false);
return(MessageConverter.GetMessagesDto(messages));
}
}
/// <summary>
/// Receives a batch of <see cref="EventData" /> from the Event Hub partition.
/// </summary>
///
/// <param name="maximumMessageCount">The maximum number of messages to receive in this batch.</param>
/// <param name="maximumWaitTime">The maximum amount of time to wait to build up the requested message count for the batch; if not specified, the per-try timeout specified by the retry policy will be used.</param>
/// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
///
/// <returns>The batch of <see cref="EventData" /> from the Event Hub partition this consumer is associated with. If no events are present, an empty set is returned.</returns>
///
public override async Task <IReadOnlyList <EventData> > ReceiveAsync(int maximumMessageCount,
TimeSpan?maximumWaitTime,
CancellationToken cancellationToken)
{
Argument.AssertNotClosed(_closed, nameof(AmqpConsumer));
Argument.AssertAtLeast(maximumMessageCount, 1, nameof(maximumMessageCount));
var receivedEventCount = 0;
var failedAttemptCount = 0;
var tryTimeout = RetryPolicy.CalculateTryTimeout(0);
var waitTime = (maximumWaitTime ?? tryTimeout);
var link = default(ReceivingAmqpLink);
var retryDelay = default(TimeSpan?);
var amqpMessages = default(IEnumerable <AmqpMessage>);
var receivedEvents = default(List <EventData>);
var lastReceivedEvent = default(EventData);
var stopWatch = Stopwatch.StartNew();
try
{
while ((!cancellationToken.IsCancellationRequested) && (!_closed))
{
try
{
EventHubsEventSource.Log.EventReceiveStart(EventHubName, ConsumerGroup, PartitionId);
link = await ReceiveLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout)).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
var messagesReceived = await Task.Factory.FromAsync
(
(callback, state) => link.BeginReceiveMessages(maximumMessageCount, waitTime, callback, state),
(asyncResult) => link.EndReceiveMessages(asyncResult, out amqpMessages),
TaskCreationOptions.RunContinuationsAsynchronously
).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
// If event messages were received, then package them for consumption and
// return them.
if ((messagesReceived) && (amqpMessages != null))
{
receivedEvents ??= new List <EventData>();
foreach (AmqpMessage message in amqpMessages)
{
link.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome);
receivedEvents.Add(MessageConverter.CreateEventFromMessage(message));
message.Dispose();
}
receivedEventCount = receivedEvents.Count;
if (receivedEventCount > 0)
{
lastReceivedEvent = receivedEvents[receivedEventCount - 1];
if (lastReceivedEvent.Offset > long.MinValue)
{
CurrentEventPosition = EventPosition.FromOffset(lastReceivedEvent.Offset, false);
}
if (TrackLastEnqueuedEventProperties)
{
LastReceivedEvent = lastReceivedEvent;
}
}
return(receivedEvents);
}
// No events were available.
return(new List <EventData>(0));
}
catch (EventHubsException ex) when(ex.Reason == EventHubsException.FailureReason.ServiceTimeout)
{
// Because the timeout specified with the request is intended to be the maximum
// amount of time to wait for events, a timeout isn't considered an error condition,
// rather a sign that no events were available in the requested period.
return(new List <EventData>(0));
}
catch (Exception ex)
{
Exception activeEx = ex.TranslateServiceException(EventHubName);
// Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop.
// Otherwise, bubble the exception.
++failedAttemptCount;
retryDelay = RetryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount);
if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!cancellationToken.IsCancellationRequested))
{
EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, activeEx.Message);
await Task.Delay(UseMinimum(retryDelay.Value, waitTime.CalculateRemaining(stopWatch.Elapsed)), cancellationToken).ConfigureAwait(false);
tryTimeout = RetryPolicy.CalculateTryTimeout(failedAttemptCount);
}
else if (ex is AmqpException)
{
ExceptionDispatchInfo.Capture(activeEx).Throw();
}
else
{
throw;
}
}
}
// If no value has been returned nor exception thrown by this point,
// then cancellation has been requested.
throw new TaskCanceledException();
}
catch (Exception ex)
{
EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, ex.Message);
throw;
}
finally
{
stopWatch.Stop();
EventHubsEventSource.Log.EventReceiveComplete(EventHubName, ConsumerGroup, PartitionId, receivedEventCount);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _u3dPlayerControl_UnityCall(object sender, AxUnityWebPlayerAXLib._DUnityWebPlayerAXEvents_OnExternalCallEvent e)
{
try
{
string message = e.value;
string[] list = message.Split('"');
for (int i = 0; i < list.Length; i++)
{
if (list[i].StartsWith("@"))
{
iS3UnityMessage myMessage = MessageConverter.DeSerializeMessage(list[i]);
switch (myMessage.type)
{
case MessageType.SendUnityLayer:
SendUnityLayerMessage _message0 = myMessage as SendUnityLayerMessage;
if (UnityLayerHandler != null)
{
UnityLayerHandler(this, _message0.MyUnityLayer);
}
break;
case MessageType.SetObjSelectState:
SetObjSelectStateMessage _message = myMessage as SetObjSelectStateMessage;
string _path = _message.path;
int id = int.Parse(_path.Split('/')[_path.Split('/').Length - 1]);
bool isSelected = _message.iSSelected;
DGObject obj = null;
foreach (string key in prj.objsLayerIndex.Keys)
{
DGObjects objs = prj.objsLayerIndex[key];
if ((objs.definition.Has3D) && (_path.StartsWith(objs.definition.Layer3DName)))
{
foreach (DGObject _obj in objs.values)
{
if (_obj.fullName == id.ToString())
{
obj = _obj;
break;
}
}
}
}
if (obj != null && objSelectionChangedTrigger != null)
{
ObjSelectionChangedEventArgs args = new ObjSelectionChangedEventArgs();
if (isSelected)
{
args.addedObjs = new Dictionary <string, IEnumerable <DGObject> >();
List <DGObject> objs = new List <DGObject>()
{
obj
};
args.addedObjs.Add(obj.parent.definition.GISLayerName, objs);
}
else
{
args.removedObjs = new Dictionary <string, IEnumerable <DGObject> >();
List <DGObject> objs = new List <DGObject>()
{
obj
};
args.removedObjs.Add(obj.parent.definition.GISLayerName, objs);
}
objSelectionChangedTrigger(this, args);
}
break;
case MessageType.SetObjShowState:
break;
default: break;
}
}
}
}
catch { }
}
private async Task <List <MessageDto> > DeleteChannelMessagesInfoAsync(long channelId, IEnumerable <Guid> messagesIds, long userId)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
var messagesCondition = PredicateBuilder.New <Message>();
messagesCondition = messagesIds.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value).Expand());
var channelUser = await context.ChannelUsers
.Include(opt => opt.Channel)
.FirstOrDefaultAsync(opt =>
opt.ChannelId == channelId &&
opt.UserId == userId &&
opt.ChannelUserRole >= ChannelUserRole.Administrator)
.ConfigureAwait(false);
if (channelUser == null)
{
throw new PermissionDeniedException();
}
var messages = await context.Messages
.Include(opt => opt.Attachments)
.Where(messagesCondition)
.Where(opt => opt.ChannelId == channelId)
.ToListAsync()
.ConfigureAwait(false);
if (!messages.Any())
{
return(new List <MessageDto>());
}
var deletedMessagesIds = messages.Select(message => message.GlobalId).ToList();
var usersCondition = PredicateBuilder.New <ChannelUser>();
usersCondition = deletedMessagesIds.Aggregate(usersCondition,
(current, value) => current.Or(opt => opt.LastReadedGlobalMessageId == value).Expand());
var channelUsers = await context.ChannelUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false);
var groupedChannelUsers = channelUsers.GroupBy(opt => opt.LastReadedGlobalMessageId);
foreach (var group in groupedChannelUsers)
{
var message = await context.Messages
.OrderByDescending(opt => opt.SendingTime)
.ThenBy(opt => opt.GlobalId)
.Where(opt => !deletedMessagesIds.Contains(opt.GlobalId) && opt.ChannelId == channelId && !opt.Deleted)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
foreach (var user in group)
{
user.LastReadedGlobalMessageId = message?.GlobalId;
}
context.ChannelUsers.UpdateRange(group);
}
var deletedMessages = MessageConverter.GetMessagesDto(messages);
messages.ForEach(message =>
{
message.Deleted = true;
message.UpdatedAt = DateTime.UtcNow.ToUnixTime();
if (NodeSettings.Configs.Node.PermanentlyDeleting)
{
message.Attachments = null;
message.Replyto = null;
message.SendingTime = 0;
message.Text = null;
message.SenderId = null;
}
});
context.UpdateRange(messages);
await context.SaveChangesAsync().ConfigureAwait(false);
Message lastValidMessage = await _loadMessagesService.GetLastValidChannelMessageAsync(channelId).ConfigureAwait(false);
channelUser.Channel.LastMessageId = lastValidMessage?.Id ?? null;
channelUser.Channel.LastMessageGlobalId = lastValidMessage?.GlobalId;
context.Update(channelUser);
await context.SaveChangesAsync().ConfigureAwait(false);
return(deletedMessages);
}
}
catch (Exception ex)
{
throw new DeleteMessagesException("An error ocurred while deleting the messages.", ex);
}
}
/// <summary>
/// Retrieves information about a specific partition for an Event Hub, including elements that describe the available
/// events in the partition event stream.
/// </summary>
///
/// <param name="partitionId">The unique identifier of a partition associated with the Event Hub.</param>
/// <param name="retryPolicy">The retry policy to use as the basis for retrieving the information.</param>
/// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
///
/// <returns>The set of information for the requested partition under the Event Hub this client is associated with.</returns>
///
public override async Task <PartitionProperties> GetPartitionPropertiesAsync(string partitionId,
EventHubsRetryPolicy retryPolicy,
CancellationToken cancellationToken)
{
Argument.AssertNotClosed(_closed, nameof(AmqpClient));
Argument.AssertNotNullOrEmpty(partitionId, nameof(partitionId));
Argument.AssertNotNull(retryPolicy, nameof(retryPolicy));
var failedAttemptCount = 0;
var retryDelay = default(TimeSpan?);
var token = default(string);
var link = default(RequestResponseAmqpLink);
var stopWatch = ValueStopwatch.StartNew();
try
{
var tryTimeout = retryPolicy.CalculateTryTimeout(0);
while (!cancellationToken.IsCancellationRequested)
{
try
{
EventHubsEventSource.Log.GetPartitionPropertiesStart(EventHubName, partitionId);
// Create the request message and the management link.
token = await AcquireAccessTokenAsync(cancellationToken).ConfigureAwait(false);
using AmqpMessage request = MessageConverter.CreatePartitionPropertiesRequest(EventHubName, partitionId, token);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
link = await ManagementLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout.CalculateRemaining(stopWatch.GetElapsedTime()))).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
// Send the request and wait for the response.
using AmqpMessage response = await link.RequestAsync(request, tryTimeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
// Process the response.
AmqpError.ThrowIfErrorResponse(response, EventHubName);
return(MessageConverter.CreatePartitionPropertiesFromResponse(response));
}
catch (Exception ex)
{
Exception activeEx = ex.TranslateServiceException(EventHubName);
// Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop.
// Otherwise, mark the exception as active and break out of the loop.
++failedAttemptCount;
retryDelay = retryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount);
if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!cancellationToken.IsCancellationRequested))
{
EventHubsEventSource.Log.GetPartitionPropertiesError(EventHubName, partitionId, activeEx.Message);
await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false);
tryTimeout = retryPolicy.CalculateTryTimeout(failedAttemptCount);
stopWatch = ValueStopwatch.StartNew();
}
else if (ex is AmqpException)
{
ExceptionDispatchInfo.Capture(activeEx).Throw();
}
else
{
throw;
}
}
}
// If no value has been returned nor exception thrown by this point,
// then cancellation has been requested.
throw new TaskCanceledException();
}
catch (Exception ex)
{
EventHubsEventSource.Log.GetPartitionPropertiesError(EventHubName, partitionId, ex.Message);
throw;
}
finally
{
EventHubsEventSource.Log.GetPartitionPropertiesComplete(EventHubName, partitionId);
}
}
public async Task <List <MessageDto> > GetDialogMessagesAsync(long dialogId, long userId, Guid?lastId = null, List <AttachmentType> attachmentsTypes = null, bool direction = true, short limit = 30)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
IQueryable <Message> queryPart = context.Messages
.Include(message => message.Dialog)
.Include(message => message.Attachments);
if (lastId != null)
{
MessageDto messageQueryResult = (await GetMessagesByIdAsync(
new List <Guid>
{
lastId.Value
},
ConversationType.Dialog,
dialogId,
userId).ConfigureAwait(false)).FirstOrDefault();
if (messageQueryResult != null)
{
if (direction)
{
queryPart = queryPart
.Where(opt => opt.SendingTime < messageQueryResult.SendingTime);
}
else
{
queryPart = queryPart
.Where(opt => opt.SendingTime > messageQueryResult.SendingTime);
}
}
}
if (direction)
{
queryPart = queryPart.OrderByDescending(message => message.SendingTime)
.ThenByDescending(message => message.Id)
.ThenByDescending(message => message.GlobalId);
}
else
{
queryPart = queryPart.OrderBy(message => message.SendingTime)
.ThenBy(message => message.Id)
.ThenBy(message => message.GlobalId);
}
if (!attachmentsTypes.IsNullOrEmpty())
{
List <short> types = attachmentsTypes.Select(type => (short)type).ToList();
queryPart = queryPart.Where(opt =>
opt.Attachments.Any(attach => types.Contains(attach.Type)));
}
queryPart = queryPart.Where(message => message.DialogId == dialogId &&
message.Dialog.FirstUID == userId &&
message.Deleted == false);
queryPart = queryPart.Take(limit);
var messages = await queryPart.ToListAsync().ConfigureAwait(false);
return(MessageConverter.GetMessagesDto(messages));
}
}
catch (Exception ex)
{
throw new GetMessagesException(null, ex);
}
}
public async Task <List <MessageDto> > GetChatMessagesAsync(long chatId, long userId, Guid?navMessageId, List <AttachmentType> attachmentsTypes = null, bool direction = true, byte messagesLimit = 30)
{
if (!await loadChatsService.IsUserJoinedToChatAsync(chatId, userId).ConfigureAwait(false))
{
throw new GetMessagesException("User does not have access to chat.");
}
using (MessengerDbContext context = contextFactory.Create())
{
var messagesQuery = from message in context.Messages
where message.ChatId == chatId && message.Deleted == false
select message;
if (!attachmentsTypes.IsNullOrEmpty())
{
List <short> types = attachmentsTypes.Select(type => (short)type).ToList();
messagesQuery = messagesQuery.Where(opt =>
opt.Attachments.Any(attach => types.Contains(attach.Type)));
}
if (navMessageId != null)
{
MessageDto navigationMessage = (await GetMessagesByIdAsync(
new List <Guid>
{
navMessageId.Value
},
ConversationType.Chat,
chatId,
userId).ConfigureAwait(false)).FirstOrDefault();
if (navigationMessage != null)
{
if (direction)
{
messagesQuery = messagesQuery.Where(opt => opt.SendingTime < navigationMessage.SendingTime);
}
else
{
messagesQuery = messagesQuery.Where(opt => opt.SendingTime > navigationMessage.SendingTime);
}
}
}
if (direction)
{
messagesQuery = messagesQuery
.OrderByDescending(message => message.SendingTime)
.ThenByDescending(message => message.Id)
.ThenByDescending(message => message.GlobalId);
}
else
{
messagesQuery = messagesQuery
.OrderBy(message => message.SendingTime)
.ThenBy(message => message.Id)
.ThenBy(message => message.GlobalId);
}
var messages = await messagesQuery
.AsNoTracking()
.Include(message => message.Attachments)
.Take(messagesLimit)
.ToListAsync()
.ConfigureAwait(false);
return(MessageConverter.GetMessagesDto(messages));
}
}
public void SendMessages(HttpResponse response, IEnumerable <Message> messages)
{
response.ContentType = "text/json";
response.WriteAsync(MessageConverter.ToJson(messages));
}
protected override void Configure(FeatureConfigurationContext context, string connectionString)
{
var useCallbackReceiver = context.Settings.Get <bool>(UseCallbackReceiverSettingKey);
var maxConcurrencyForCallbackReceiver = context.Settings.Get <int>(MaxConcurrencyForCallbackReceiver);
var queueName = GetLocalAddress(context.Settings);
var callbackQueue = string.Format("{0}.{1}", queueName, RuntimeEnvironment.MachineName);
var connectionConfiguration = new ConnectionStringParser(context.Settings).Parse(connectionString);
MessageConverter messageConverter;
if (context.Settings.HasSetting(CustomMessageIdStrategy))
{
messageConverter = new MessageConverter(context.Settings.Get <Func <BasicDeliverEventArgs, string> >(CustomMessageIdStrategy));
}
else
{
messageConverter = new MessageConverter();
}
string hostDisplayName;
if (!context.Settings.TryGet("NServiceBus.HostInformation.DisplayName", out hostDisplayName))//this was added in 5.1.2 of the core
{
hostDisplayName = RuntimeEnvironment.MachineName;
}
var consumerTag = string.Format("{0} - {1}", hostDisplayName, context.Settings.EndpointName());
var receiveOptions = new ReceiveOptions(workQueue =>
{
//if this isn't the main queue we shouldn't use callback receiver
if (!useCallbackReceiver || workQueue != queueName)
{
return(SecondaryReceiveSettings.Disabled());
}
return(SecondaryReceiveSettings.Enabled(callbackQueue, maxConcurrencyForCallbackReceiver));
},
messageConverter,
connectionConfiguration.PrefetchCount,
connectionConfiguration.DequeueTimeout * 1000,
context.Settings.GetOrDefault <bool>("Transport.PurgeOnStartup"),
consumerTag);
context.Container.RegisterSingleton(connectionConfiguration);
context.Container.ConfigureComponent(builder => new RabbitMqDequeueStrategy(
builder.Build <IManageRabbitMqConnections>(),
SetupCircuitBreaker(builder.Build <CriticalError>()),
receiveOptions), DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent <OpenPublishChannelBehavior>(DependencyLifecycle.InstancePerCall);
context.Pipeline.Register <OpenPublishChannelBehavior.Registration>();
context.Pipeline.Register <ReadIncomingCallbackAddressBehavior.Registration>();
context.Container.ConfigureComponent(b => new RabbitMqMessageSender(b.Build <IRoutingTopology>(), b.Build <IChannelProvider>(), b.Build <PipelineExecutor>().CurrentContext), DependencyLifecycle.InstancePerCall);
if (useCallbackReceiver)
{
context.Container.ConfigureComponent <CallbackQueueCreator>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.Enabled, true)
.ConfigureProperty(p => p.CallbackQueueAddress, Address.Parse(callbackQueue));
//context.Pipeline.Register<ForwardCallbackQueueHeaderBehavior.Registration>();
context.Pipeline.Register <SetOutgoingCallbackAddressBehavior.Registration>();
context.Container.ConfigureComponent <SetOutgoingCallbackAddressBehavior>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.CallbackQueue, callbackQueue);
}
context.Container.ConfigureComponent <ChannelProvider>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.UsePublisherConfirms, connectionConfiguration.UsePublisherConfirms)
.ConfigureProperty(p => p.MaxWaitTimeForConfirms, connectionConfiguration.MaxWaitTimeForConfirms);
context.Container.ConfigureComponent <RabbitMqDequeueStrategy>(DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent <RabbitMqMessagePublisher>(DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent <RabbitMqSubscriptionManager>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.EndpointQueueName, queueName);
context.Container.ConfigureComponent <RabbitMqQueueCreator>(DependencyLifecycle.InstancePerCall);
if (context.Settings.HasSetting <IRoutingTopology>())
{
context.Container.RegisterSingleton(context.Settings.Get <IRoutingTopology>());
}
else
{
var durable = GetDurableMessagesEnabled(context.Settings);
IRoutingTopology topology;
DirectRoutingTopology.Conventions conventions;
if (context.Settings.TryGet(out conventions))
{
topology = new DirectRoutingTopology(conventions, durable);
}
else
{
topology = new ConventionalRoutingTopology(durable);
}
context.Container.RegisterSingleton(topology);
}
if (context.Settings.HasSetting("IManageRabbitMqConnections"))
{
context.Container.ConfigureComponent(context.Settings.Get <Type>("IManageRabbitMqConnections"), DependencyLifecycle.SingleInstance);
}
else
{
context.Container.ConfigureComponent <RabbitMqConnectionManager>(DependencyLifecycle.SingleInstance);
context.Container.ConfigureComponent(builder => new RabbitMqConnectionFactory(builder.Build <ConnectionConfiguration>()), DependencyLifecycle.InstancePerCall);
}
}
public override VisualLineElement ConstructElement(int offset)
{
var result = this.FindMatch(offset);
if (result != null)
{
if (result.Type == "State")
{
var size = (double)new FontSizeConverter().ConvertFromString(Settings.Instance.Global_Fonts_Message_FontSize + "pt");
var image = new Image()
{
Height = (size - 3), Width = (size - 3), Margin = new Thickness(1.5, 1.5, 0, 0)
};
if (result.Value == "#")
{
image.Source = StatesIconManager.Instance.Green;
}
else if (result.Value == "!")
{
image.Source = StatesIconManager.Instance.Red;
}
else if (result.Value == "@")
{
image.Source = StatesIconManager.Instance.Yello;
}
var element = new CustomObjectElement(result.Value, image);
element.ClickEvent += (string text) =>
{
this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length));
};
return(element);
}
else if (result.Type == "Signature")
{
Brush brush;
if (Inspect.ContainTrustSignature(result.Value))
{
brush = new SolidColorBrush(_serviceManager.Config.Colors.Message_Trust);
}
else
{
brush = new SolidColorBrush(_serviceManager.Config.Colors.Message_Untrust);
}
var element = new CustomTextElement(result.Value);
element.Foreground = brush;
element.ClickEvent += (string text) =>
{
this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length));
};
return(element);
}
else if (result.Type == "Uri")
{
var uri = result.Value;
CustomObjectElement element = null;
if (uri.StartsWith("http:") | uri.StartsWith("https:"))
{
var textBlock = new TextBlock();
textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : "");
textBlock.ToolTip = HttpUtility.UrlDecode(uri);
if (Settings.Instance.Global_UrlHistorys.Contains(uri))
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link);
}
else
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New);
}
element = new CustomObjectElement(uri, textBlock);
}
else if (uri.StartsWith("Tag:"))
{
var tag = AmoebaConverter.FromTagString(uri);
var textBlock = new TextBlock();
textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : "");
textBlock.ToolTip = MessageConverter.ToInfoMessage(tag);
if (Settings.Instance.Global_TagHistorys.Contains(tag))
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link);
}
else
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New);
}
element = new CustomObjectElement(uri, textBlock);
}
else if (uri.StartsWith("Seed:"))
{
var seed = AmoebaConverter.FromSeedString(uri);
var textBlock = new TextBlock();
textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : "");
textBlock.ToolTip = MessageConverter.ToInfoMessage(seed);
if (Settings.Instance.Global_SeedHistorys.Contains(seed))
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link);
}
else
{
textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New);
}
element = new CustomObjectElement(uri, textBlock);
}
if (element != null)
{
element.ClickEvent += (string text) =>
{
this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length));
this.OnClickEvent(text);
};
return(element);
}
}
}
return(null);
}
public async Task <Response> CreateResponseAsync()
{
List <MessageDto> updatedMessages = await loadMessagesService.GetUserUpdatedMessagesAsync(
clientConnection.UserId.GetValueOrDefault(),
request.Start.GetValueOrDefault(),
request.ConversationId,
request.ConversationType,
request.MessageId)
.ConfigureAwait(false);
if (!updatedMessages.Any())
{
return(new UpdatedMessagesResponse(request.RequestId, null, null, null, null, null, Array.Empty <MessageInfo>(), null));
}
IEnumerable <IGrouping <ConversationType, MessageDto> > groupingMessages;
List <MessageInfo> messageInfo = new List <MessageInfo>();
List <MessageVm> editedMessages = new List <MessageVm>();
long startUpdatedTime = updatedMessages.FirstOrDefault().UpdatedAt.GetValueOrDefault();
long? endUpdatedTime = null;
long? endConversationId = null;
Guid? endMessageId = null;
ConversationType?endConversationType = null;
if (updatedMessages.Count() < UPDATES_LIMIT)
{
groupingMessages = updatedMessages.GroupBy(opt => opt.ConversationType);
}
else
{
List <MessageDto> partOfMessages = updatedMessages.Take(UPDATES_LIMIT).ToList();
MessageDto lastMessage = partOfMessages.LastOrDefault();
groupingMessages = partOfMessages.GroupBy(opt => opt.ConversationType);
endUpdatedTime = lastMessage.UpdatedAt;
endConversationId = lastMessage.ConversationId;
endConversationType = lastMessage.ConversationType;
endMessageId = lastMessage.GlobalId;
}
foreach (var group in groupingMessages)
{
var conversationGroupingMessages = group.GroupBy(opt => opt.ConversationId);
foreach (var messages in conversationGroupingMessages)
{
var deletedMessagesId = messages.Where(opt => opt.Deleted)?.Select(opt => opt.GlobalId);
if (deletedMessagesId != null && deletedMessagesId.Any())
{
messageInfo.Add(
new MessageInfo(
messages.Key,
group.Key,
deletedMessagesId));
}
var edited = MessageConverter.GetMessagesVm(
messages.Where(opt => !opt.Deleted),
clientConnection.UserId.GetValueOrDefault());
if (edited != null && edited.Any())
{
editedMessages.AddRange(edited);
}
}
}
return(new UpdatedMessagesResponse(request.RequestId, startUpdatedTime, endUpdatedTime, endConversationId, endConversationType, endMessageId, messageInfo, editedMessages));
}
private async Task <List <MessageDto> > DeleteChatMessagesInfoAsync(long chatId, IEnumerable <Guid> messagesIds, long userId)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
var messagesCondition = PredicateBuilder.New <Message>();
messagesCondition = messagesIds.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value && opt.ChatId == chatId && opt.Deleted == false));
var query = from conversation in context.Chats
join chatUser in context.ChatUsers on conversation.Id equals chatUser.ChatId
where chatUser.Banned == false &&
chatUser.Deleted == false &&
conversation.Deleted == false &&
chatUser.UserId == userId &&
conversation.Id == chatId
select new
{
Chat = conversation,
User = chatUser
};
var result = await query.FirstOrDefaultAsync().ConfigureAwait(false);
if (result == null || result.User == null)
{
return(new List <MessageDto>());
}
List <Message> messages = await context.Messages
.Include(opt => opt.Attachments)
.Where(messagesCondition)
.ToListAsync()
.ConfigureAwait(false);
if (!messages.Any())
{
return(new List <MessageDto>());
}
var deletedMessagesIds = messages.Select(message => message.GlobalId).ToList();
var usersCondition = PredicateBuilder.New <ChatUser>();
usersCondition = deletedMessagesIds.Aggregate(usersCondition,
(current, value) => current.Or(opt => opt.LastReadedGlobalMessageId == value).Expand());
var chatUsers = await context.ChatUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false);
var groupedChatUsers = chatUsers.GroupBy(opt => opt.LastReadedGlobalMessageId);
foreach (var group in groupedChatUsers)
{
var message = await context.Messages
.OrderByDescending(opt => opt.SendingTime)
.ThenBy(opt => opt.GlobalId)
.Where(opt => !deletedMessagesIds.Contains(opt.GlobalId) && opt.ChatId == chatId && !opt.Deleted)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
foreach (var chatUser in group)
{
chatUser.LastReadedGlobalMessageId = message?.GlobalId;
}
context.ChatUsers.UpdateRange(group);
}
List <MessageDto> deletedMessages = MessageConverter.GetMessagesDto(messages);
foreach (var message in messages)
{
if (message.SenderId != result.User.UserId && result.User.UserRole == UserRole.User)
{
continue;
}
message.Deleted = true;
message.UpdatedAt = DateTime.UtcNow.ToUnixTime();
if (NodeSettings.Configs.Node.PermanentlyDeleting)
{
message.Attachments = null;
message.Replyto = null;
message.SendingTime = 0;
message.Text = null;
message.SenderId = null;
}
}
context.UpdateRange(messages);
await context.SaveChangesAsync().ConfigureAwait(false);
Message lastMessage = await _loadMessagesService.GetLastValidChatMessageAsync(chatId).ConfigureAwait(false);
result.Chat.LastMessageId = lastMessage?.Id ?? null;
result.Chat.LastMessageGlobalId = lastMessage?.GlobalId;
context.Update(result.Chat);
await context.SaveChangesAsync().ConfigureAwait(false);
return(deletedMessages);
}
}
catch (Exception ex)
{
throw new DeleteMessagesException("An error occurred while deleting messages.", ex);
}
}
public void ExcuteCommand(iS3UnityMessage message)
{
ExcuteCommand(MessageConverter.SerializeMessage(message));
}
public async Task <List <MessageDto> > GetMessagesAsync(long conversationId, ConversationType conversationType, bool direction, Guid?messageId, List <AttachmentType> attachmentsTypes, int limit)
{
using (MessengerDbContext context = contextFactory.Create())
{
IQueryable <Message> query = context.Messages
.Where(message => message.ExpiredAt > DateTime.UtcNow.ToUnixTime() || message.ExpiredAt == null)
.Where(message => !message.Deleted);
Message navigationMessage = null;
switch (conversationType)
{
case ConversationType.Dialog:
{
navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.DialogId == conversationId).ConfigureAwait(false);
query = query.Where(opt => opt.DialogId == conversationId);
}
break;
case ConversationType.Chat:
{
navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.ChatId == conversationId).ConfigureAwait(false);
query = query.Where(opt => opt.ChatId == conversationId);
}
break;
case ConversationType.Channel:
{
navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.ChannelId == conversationId).ConfigureAwait(false);
query = query.Where(opt => opt.ChannelId == conversationId);
}
break;
}
if (navigationMessage != null)
{
query = direction
? query.Where(opt => opt.Id < navigationMessage.Id)
: query.Where(opt => opt.Id > navigationMessage.Id);
}
if (!attachmentsTypes.IsNullOrEmpty())
{
List <short> types = attachmentsTypes.Select(type => (short)type).ToList();
query = query.Where(opt =>
opt.Attachments.Any(attach => types.Contains(attach.Type)));
}
query = direction
? query.OrderByDescending(message => message.SendingTime)
.ThenByDescending(message => message.Id)
.ThenByDescending(message => message.GlobalId)
: query.OrderBy(message => message.SendingTime)
.ThenBy(message => message.Id)
.ThenBy(message => message.GlobalId);
var messages = await query
.AsNoTracking()
.Include(message => message.Attachments)
.Take(limit)
.ToListAsync()
.ConfigureAwait(false);
return(MessageConverter.GetMessagesDto(messages));
}
}
public async Task <List <MessageDto> > GetUserUpdatedMessagesAsync(long userId, long updatedTime, long?conversationId, ConversationType?conversationType, Guid?messageId, int limit = 1000)
{
IEnumerable <long> userDialogsIds = await loadDialogsService.GetUserDialogsIdAsync(userId).ConfigureAwait(false);
IEnumerable <long> userChatsIds = await loadChatsService.GetUserChatsIdAsync(userId).ConfigureAwait(false);
IEnumerable <long> userChannelsIds = await loadChannelsService.GetUserChannelsIdAsync(userId).ConfigureAwait(false);
var messagesCondition = PredicateBuilder.New <Message>();
messagesCondition = userDialogsIds.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.DialogId == value));
messagesCondition = messagesCondition.Or(opt => userChatsIds.Contains(opt.ChatId.GetValueOrDefault()));
messagesCondition = messagesCondition.Or(opt => userChannelsIds.Contains(opt.ChannelId.GetValueOrDefault())).Expand();
List <Message> updatedMessages = new List <Message>();
Message navigationMessage = null;
using (MessengerDbContext context = contextFactory.Create())
{
switch (conversationType.GetValueOrDefault())
{
case ConversationType.Dialog:
{
navigationMessage = await context.Messages
.FirstOrDefaultAsync(message => message.DialogId == conversationId && message.GlobalId == messageId)
.ConfigureAwait(false);
}
break;
case ConversationType.Chat:
{
navigationMessage = await context.Messages
.FirstOrDefaultAsync(message => message.ChatId == conversationId && message.GlobalId == messageId)
.ConfigureAwait(false);
}
break;
case ConversationType.Channel:
{
navigationMessage = await context.Messages
.FirstOrDefaultAsync(message => message.ChannelId == conversationId && message.GlobalId == messageId)
.ConfigureAwait(false);
}
break;
}
if (navigationMessage == null)
{
navigationMessage = new Message {
Id = 0
};
}
updatedMessages = await context.Messages
.Where(messagesCondition)
.Where(opt => opt.UpdatedAt >= updatedTime)
.Where(opt => opt.ExpiredAt > DateTime.UtcNow.ToUnixTime() || opt.ExpiredAt == null)
.Take(limit)
.ToListAsync()
.ConfigureAwait(false);
updatedMessages = updatedMessages
.OrderBy(opt => opt.UpdatedAt)
.ThenBy(opt => opt.Id)
.ThenBy(opt => opt.GlobalId)
.Where(opt => opt.Id > navigationMessage.Id)
.ToList();
return(MessageConverter.GetMessagesDto(updatedMessages));
}
}
/// <summary>
/// Receives a batch of <see cref="EventData" /> from the Event Hub partition.
/// </summary>
///
/// <param name="maximumEventCount">The maximum number of messages to receive in this batch.</param>
/// <param name="maximumWaitTime">The maximum amount of time to wait for events to become available, if no events can be read from the prefetch queue. If not specified, the per-try timeout specified by the retry policy will be used.</param>
/// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
///
/// <returns>The batch of <see cref="EventData" /> from the Event Hub partition this consumer is associated with. If no events are present, an empty set is returned.</returns>
///
/// <remarks>
/// When events are available in the prefetch queue, they will be used to form the batch as quickly as possible without waiting for additional events from the
/// Event Hubs service to try and meet the requested <paramref name="maximumEventCount" />. When no events are available in prefetch, the receiver will wait up
/// to the <paramref name="maximumWaitTime"/> for events to be read from the service. Once any events are available, they will be used to form the batch immediately.
/// </remarks>
///
public override async Task <IReadOnlyList <EventData> > ReceiveAsync(int maximumEventCount,
TimeSpan?maximumWaitTime,
CancellationToken cancellationToken)
{
Argument.AssertNotClosed(_closed, nameof(AmqpConsumer));
Argument.AssertNotClosed(ConnectionScope.IsDisposed, nameof(EventHubConnection));
Argument.AssertAtLeast(maximumEventCount, 1, nameof(maximumEventCount));
var receivedEventCount = 0;
var failedAttemptCount = 0;
var tryTimeout = RetryPolicy.CalculateTryTimeout(0);
var waitTime = (maximumWaitTime ?? tryTimeout);
var operationId = Guid.NewGuid().ToString("D", CultureInfo.InvariantCulture);
var link = default(ReceivingAmqpLink);
var retryDelay = default(TimeSpan?);
var receivedEvents = default(List <EventData>);
var lastReceivedEvent = default(EventData);
var stopWatch = ValueStopwatch.StartNew();
try
{
while ((!cancellationToken.IsCancellationRequested) && (!_closed))
{
try
{
// Creation of the link happens without explicit knowledge of the cancellation token
// used for this operation; validate the token state before attempting link creation and
// again after the operation completes to provide best efforts in respecting it.
EventHubsEventSource.Log.EventReceiveStart(EventHubName, ConsumerGroup, PartitionId, operationId);
if (!ReceiveLink.TryGetOpenedObject(out link))
{
link = await ReceiveLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout), cancellationToken).ConfigureAwait(false);
}
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
var messagesReceived = await link.ReceiveMessagesAsync(maximumEventCount, ReceiveBuildBatchInterval, waitTime, cancellationToken).ConfigureAwait(false);
// If no messages were received, then just return the empty set.
if (messagesReceived == null)
{
return(EmptyEventSet);
}
// If event messages were received, then package them for consumption and
// return them.
foreach (AmqpMessage message in messagesReceived)
{
receivedEvents ??= new List <EventData>();
link.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome);
receivedEvents.Add(MessageConverter.CreateEventFromMessage(message));
message.Dispose();
receivedEventCount = receivedEvents.Count;
}
if (receivedEventCount > 0)
{
lastReceivedEvent = receivedEvents[receivedEventCount - 1];
if (lastReceivedEvent.Offset > long.MinValue)
{
CurrentEventPosition = EventPosition.FromOffset(lastReceivedEvent.Offset, false);
}
if (TrackLastEnqueuedEventProperties)
{
LastReceivedEvent = lastReceivedEvent;
}
}
return(receivedEvents ?? EmptyEventSet);
}
catch (EventHubsException ex) when(ex.Reason == EventHubsException.FailureReason.ServiceTimeout)
{
// Because the timeout specified with the request is intended to be the maximum
// amount of time to wait for events, a timeout isn't considered an error condition,
// rather a sign that no events were available in the requested period.
return(EmptyEventSet);
}
catch (Exception ex)
{
Exception activeEx = ex.TranslateServiceException(EventHubName);
// If the partition was stolen determine the correct action to take for
// capturing it with respect to whether the consumer should be invalidated.
//
// In either case, it is a terminal exception and will not trigger a retry;
// allow the normal error handling flow to surface the exception.
if (ex.IsConsumerPartitionStolenException())
{
// If the consumer should be invalidated, capture the exception
// and force-close the link. This will ensure that the next operation
// will surface it.
if (InvalidateConsumerWhenPartitionStolen)
{
_activePartitionStolenException = ex;
CloseConsumerLink(link);
}
else
{
// If the consumer should not be invalidated, clear any previously captured exception to avoid
// surfacing the failure multiple times. If the link is stolen after this operation, it will
// be intercepted and handled as needed.
_activePartitionStolenException = null;
}
}
// Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop.
// Otherwise, bubble the exception.
++failedAttemptCount;
retryDelay = RetryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount);
if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!_closed) && (!cancellationToken.IsCancellationRequested))
{
EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, operationId, activeEx.Message);
await Task.Delay(UseMinimum(retryDelay.Value, waitTime.CalculateRemaining(stopWatch.GetElapsedTime())), cancellationToken).ConfigureAwait(false);
tryTimeout = RetryPolicy.CalculateTryTimeout(failedAttemptCount);
}
else if (ex is AmqpException)
{
ExceptionDispatchInfo.Capture(activeEx).Throw();
}
else
{
throw;
}
}
}
// If no value has been returned nor exception thrown by this point,
// then cancellation has been requested.
throw new TaskCanceledException();
}
catch (TaskCanceledException)
{
throw;
}
catch (Exception ex)
{
EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, operationId, ex.Message);
throw;
}
finally
{
EventHubsEventSource.Log.EventReceiveComplete(EventHubName, ConsumerGroup, PartitionId, operationId, failedAttemptCount, receivedEventCount);
}
}
public async Task <List <MessageDto> > GetChannelMessagesAsync(long channelId, long userId, Guid?navigationMessageId, List <AttachmentType> attachmentsTypes = null, bool direction = true, byte limit = 30)
{
using (MessengerDbContext context = contextFactory.Create())
{
var query = context.Messages.Where(opt => opt.ChannelId == channelId && opt.Deleted == false);
if (navigationMessageId != null)
{
var navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == navigationMessageId && opt.ChannelId == channelId).ConfigureAwait(false);
if (navigationMessage != null)
{
if (direction)
{
query = query.Where(opt => opt.Id < navigationMessage.Id);
}
else
{
query = query.Where(opt => opt.Id > navigationMessage.Id);
}
}
}
if (direction)
{
query = query
.OrderByDescending(message => message.SendingTime)
.ThenByDescending(message => message.Id)
.ThenByDescending(message => message.GlobalId);
}
else
{
query = query
.OrderBy(message => message.SendingTime)
.ThenBy(message => message.Id)
.ThenBy(message => message.GlobalId);
}
if (!attachmentsTypes.IsNullOrEmpty())
{
List <short> types = attachmentsTypes.Select(type => (short)type).ToList();
query = query.Where(opt =>
opt.Attachments.Any(attach => types.Contains(attach.Type)));
}
var messages = await query
.AsNoTracking()
.Include(message => message.Attachments)
.Take(limit)
.ToListAsync()
.ConfigureAwait(false);
var channelUser = await context.ChannelUsers.FirstOrDefaultAsync(opt => opt.ChannelId == channelId && opt.UserId == userId).ConfigureAwait(false);
if (channelUser != null)
{
var lastReadedMessage = await context.Messages
.FirstOrDefaultAsync(opt => opt.GlobalId == channelUser.LastReadedGlobalMessageId && opt.ChannelId == channelId).ConfigureAwait(false);
if (lastReadedMessage != null)
{
messages.ForEach(message =>
{
if (message.Id > lastReadedMessage.Id && message.SenderId != userId)
{
message.Read = false;
}
else
{
message.Read = true;
}
});
}
}
return(MessageConverter.GetMessagesDto(messages));
}
}
private async Task HandleChannelMessagesAsync(IEnumerable <MessageVm> messages)
{
foreach (var message in messages)
{
bool hasException = true;
MessageDto sentMessage = null;
while (hasException)
{
try
{
if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault()))
{
hasException = false;
continue;
}
if (message.Attachments != null)
{
foreach (var attachment in message.Attachments)
{
attachment.MessageId = 0;
}
await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false);
await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false);
}
sentMessage = await createMessagesService.CreateChannelMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false);
hasException = false;
}
catch (ConversationNotFoundException ex)
{
var channel = await nodeRequestSender.GetChannelInformationAsync(ex.ConversationId, current).ConfigureAwait(false);
await createChannelsService.CreateOrUpdateUserChannelsAsync(new List <ChannelDto> {
channel
}).ConfigureAwait(false);
hasException = true;
}
catch (UserNotFoundException ex)
{
List <UserVm> users = new List <UserVm>(await nodeRequestSender.GetUsersInfoAsync(ex.UsersId.ToList(), null, current).ConfigureAwait(false));
await crossNodeService.CreateNewUsersAsync(users).ConfigureAwait(false);
hasException = true;
}
catch (Exception ex)
{
Logger.WriteLog(ex);
hasException = false;
}
}
SendChannelNotificationsAsync(sentMessage);
}
}
public async Task <List <MessageDto> > DialogMessagesReadAsync(IEnumerable <Guid> messagesId, long dialogId, long userId)
{
var messagesCondition = PredicateBuilder.New <Message>();
messagesCondition = messagesId.Aggregate(messagesCondition,
(current, value) => current.Or(message => message.GlobalId == value).Expand());
using (MessengerDbContext context = contextFactory.Create())
{
var messages = await context.Messages
.Where(messagesCondition)
.Where(message => (message.Dialog.Id == dialogId) && !message.Read)
.ToListAsync()
.ConfigureAwait(false);
if (!messages.Any())
{
throw new WrongArgumentException();
}
var earlierMessage = messages.OrderBy(message => message.SendingTime).FirstOrDefault();
if (earlierMessage != null)
{
var unreadedMessages = await context.Messages
.Where(message => message.SendingTime < earlierMessage.SendingTime && !message.Read && message.DialogId == dialogId)
.ToListAsync()
.ConfigureAwait(false);
List <Message> earlierUnreadedMessages = new List <Message>();
foreach (var readedMessage in unreadedMessages)
{
if (readedMessage.SenderId != userId)
{
readedMessage.Read = true;
var sameMessage = await context.Messages
.FirstOrDefaultAsync(message => message.Id == readedMessage.SameMessageId)
.ConfigureAwait(false);
sameMessage.Read = true;
earlierUnreadedMessages.Add(sameMessage);
}
}
}
List <Message> sameMessages = new List <Message>();
foreach (var readedMessage in messages)
{
if (readedMessage.SenderId != userId)
{
readedMessage.Read = true;
var sameMessage = await context.Messages
.FirstOrDefaultAsync(message => message.Id == readedMessage.SameMessageId).ConfigureAwait(false);
if (sameMessage == null)
{
sameMessages.Add(readedMessage);
}
else
{
sameMessage.Read = true;
sameMessages.Add(sameMessage);
}
}
}
await context.SaveChangesAsync().ConfigureAwait(false);
return(MessageConverter.GetMessagesDto(sameMessages));
}
}
protected override void Configure(FeatureConfigurationContext context, string connectionString)
{
var useCallbackReceiver = context.Settings.Get<bool>(UseCallbackReceiverSettingKey);
var maxConcurrencyForCallbackReceiver = context.Settings.Get<int>(MaxConcurrencyForCallbackReceiver);
var queueName = GetLocalAddress(context.Settings);
var callbackQueue = string.Format("{0}.{1}", queueName, RuntimeEnvironment.MachineName);
var connectionConfiguration = new ConnectionStringParser(context.Settings).Parse(connectionString);
MessageConverter messageConverter;
if (context.Settings.HasSetting(CustomMessageIdStrategy))
{
messageConverter = new MessageConverter(context.Settings.Get<Func<BasicDeliverEventArgs, string>>(CustomMessageIdStrategy));
}
else
{
messageConverter = new MessageConverter();
}
string hostDisplayName;
if (!context.Settings.TryGet("NServiceBus.HostInformation.DisplayName", out hostDisplayName))//this was added in 5.1.2 of the core
{
hostDisplayName = RuntimeEnvironment.MachineName;
}
var consumerTag = string.Format("{0} - {1}", hostDisplayName, context.Settings.EndpointName());
var receiveOptions = new ReceiveOptions(workQueue =>
{
//if this isn't the main queue we shouldn't use callback receiver
if (!useCallbackReceiver || workQueue != queueName)
{
return SecondaryReceiveSettings.Disabled();
}
return SecondaryReceiveSettings.Enabled(callbackQueue, maxConcurrencyForCallbackReceiver);
},
messageConverter,
connectionConfiguration.PrefetchCount,
connectionConfiguration.DequeueTimeout * 1000,
context.Settings.GetOrDefault<bool>("Transport.PurgeOnStartup"),
consumerTag);
context.Container.RegisterSingleton(connectionConfiguration);
context.Container.ConfigureComponent(builder => new RabbitMqDequeueStrategy(
builder.Build<IManageRabbitMqConnections>(),
SetupCircuitBreaker(builder.Build<CriticalError>()),
receiveOptions), DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent<OpenPublishChannelBehavior>(DependencyLifecycle.InstancePerCall);
context.Pipeline.Register<OpenPublishChannelBehavior.Registration>();
context.Container.ConfigureComponent<RabbitMqMessageSender>(DependencyLifecycle.InstancePerCall);
if (useCallbackReceiver)
{
context.Container.ConfigureProperty<RabbitMqMessageSender>(p => p.CallbackQueue, callbackQueue);
context.Container.ConfigureComponent<CallbackQueueCreator>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.Enabled, true)
.ConfigureProperty(p => p.CallbackQueueAddress, Address.Parse(callbackQueue));
context.Pipeline.Register<ForwardCallbackQueueHeaderBehavior.Registration>();
}
context.Container.ConfigureComponent<ChannelProvider>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.UsePublisherConfirms, connectionConfiguration.UsePublisherConfirms)
.ConfigureProperty(p => p.MaxWaitTimeForConfirms, connectionConfiguration.MaxWaitTimeForConfirms);
context.Container.ConfigureComponent<RabbitMqDequeueStrategy>(DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent<RabbitMqMessagePublisher>(DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent<RabbitMqSubscriptionManager>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.EndpointQueueName, queueName);
context.Container.ConfigureComponent<RabbitMqQueueCreator>(DependencyLifecycle.InstancePerCall);
if (context.Settings.HasSetting<IRoutingTopology>())
{
context.Container.RegisterSingleton(context.Settings.Get<IRoutingTopology>());
}
else
{
var durable = GetDurableMessagesEnabled(context.Settings);
IRoutingTopology topology;
DirectRoutingTopology.Conventions conventions;
if (context.Settings.TryGet(out conventions))
{
topology = new DirectRoutingTopology(conventions, durable);
}
else
{
topology = new ConventionalRoutingTopology(durable);
}
context.Container.RegisterSingleton(topology);
}
if (context.Settings.HasSetting("IManageRabbitMqConnections"))
{
context.Container.ConfigureComponent(context.Settings.Get<Type>("IManageRabbitMqConnections"), DependencyLifecycle.SingleInstance);
}
else
{
context.Container.ConfigureComponent<RabbitMqConnectionManager>(DependencyLifecycle.SingleInstance);
context.Container.ConfigureComponent(builder => new RabbitMqConnectionFactory(builder.Build<ConnectionConfiguration>()), DependencyLifecycle.InstancePerCall);
}
}
private async Task <List <MessageDto> > DeleteDialogMessagesInfoAsync(long dialogId, IEnumerable <Guid> messagesIds, long userId)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
long mirrorDialogId = await _loadDialogsService.GetMirrorDialogIdAsync(dialogId).ConfigureAwait(false);
var messagesCondition = PredicateBuilder.New <Message>();
messagesCondition = messagesIds.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value &&
(opt.DialogId == dialogId || opt.DialogId == mirrorDialogId) &&
(opt.SenderId == userId || opt.ReceiverId == userId)).Expand());
List <MessageDto> deletedMessages;
List <Message> messages = await context.Messages
.Include(opt => opt.Attachments)
.Where(messagesCondition)
.ToListAsync()
.ConfigureAwait(false);
if (!messages.Any())
{
return(new List <MessageDto>());
}
deletedMessages = MessageConverter.GetMessagesDto(messages);
Dialog firstDialog = await context.Dialogs.FirstOrDefaultAsync(opt => opt.Id == dialogId).ConfigureAwait(false);
Dialog mirrorDialog = await context.Dialogs.FirstOrDefaultAsync(opt => opt.Id == mirrorDialogId).ConfigureAwait(false);
foreach (var message in messages)
{
message.Deleted = true;
message.UpdatedAt = DateTime.UtcNow.ToUnixTime();
if (NodeSettings.Configs.Node.PermanentlyDeleting)
{
message.Attachments = null;
message.Replyto = null;
message.SendingTime = 0;
message.Text = null;
message.SenderId = null;
message.ReceiverId = null;
}
}
context.UpdateRange(messages);
await context.SaveChangesAsync().ConfigureAwait(false);
Message lastMessageFirstDialog = await _loadMessagesService.GetLastValidDialogMessageAsync(dialogId).ConfigureAwait(false);
Message lastMessageSecondDialog = await _loadMessagesService.GetLastValidDialogMessageAsync(mirrorDialogId).ConfigureAwait(false);
firstDialog.LastMessageId = lastMessageFirstDialog?.Id ?? null;
mirrorDialog.LastMessageId = lastMessageSecondDialog?.Id ?? null;
firstDialog.LastMessageGlobalId = lastMessageFirstDialog?.GlobalId;
mirrorDialog.LastMessageGlobalId = lastMessageSecondDialog?.GlobalId;
context.Dialogs.UpdateRange(firstDialog, mirrorDialog);
await context.SaveChangesAsync().ConfigureAwait(false);
return(deletedMessages);
}
}
catch (Exception ex)
{
throw new DeleteMessagesException("An error occurred while deleting messages.", ex);
}
}
public T Get <T>(string key)
{
if (CacheProvider.srmList != null && CacheProvider.srmList.Count > 0)
{
ServiceRequest request = new ServiceRequest();
request.ServiceName = "CacheServer";
request.MethodName = "GetObject";
request.Parameters = new object[] { key };
List <int> indexlist = new List <int>(CacheProvider.srmList.Count);
for (int i = 0; i < CacheProvider.srmList.Count; i++)
{
indexlist.Add(i);
}
Random rnd = new Random();
string errMsg = "";
while (indexlist.Count > 0)
{
int srmindex = rnd.Next(indexlist.Count);
var srm = CacheProvider.srmList[srmindex];
CacheProvider.ServiceProxy.ServiceBaseUri = srm.GetUri();
try
{
if (CacheProvider.ServiceProxy.Connect())
{
CacheProvider.ServiceProxy.ServiceSubscriber.TimeOut = 30000;//30秒
MessageConverter <T> converter = CacheProvider.ServiceProxy.GetServiceMessage <T>(request, DataType.Json);
CacheProvider.ServiceProxy.Close();
if (converter != null && converter.Succeed && !(converter.Result == null || converter.Result.Equals(default(T))))
{
return(converter.Result);
}
else
{
indexlist.RemoveAt(srmindex);
//
//此处应该记录日志，以分析缓存命中率
// string.Format("\r\n;获取缓存数据失败，Host:{0},Key:{1},ErrorMessage:{2}",srm.GetUri(), key,converter.ErrorMessage);
}
}
else
{
indexlist.RemoveAt(srmindex);
errMsg += string.Format("\r\n;获取缓存数据失败，Host:{0},Key:{1},ErrorMessage:{2}", srm.GetUri(), key, "服务器连接失败");
}
}
catch (Exception ex)
{
indexlist.RemoveAt(srmindex);
//当其中一个缓存服务宕机时不应该被终止，在此应该写日志
errMsg += string.Format("\r\n;访问缓存服务器失败，Host:{0},Key:{1},ErrorMessage:{2}", srm.GetUri(), key, ex.Message);
}
}
if (errMsg != "")
{
throw new Exception("获取缓存失败:" + errMsg);
}
else
{
return(default(T));
}
}
else
{
throw new Exception("缓存服务器列表为空");
}
}
private async Task HandleDialogMessagesAsync(IEnumerable <MessageVm> messages)
{
foreach (var message in messages)
{
bool saveMessageFlag = true;
try
{
if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault()))
{
continue;
}
if (!message.Attachments.IsNullOrEmpty())
{
foreach (var attachment in message.Attachments)
{
attachment.MessageId = 0;
}
await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false);
await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false);
}
if (!message.Attachments.IsNullOrEmpty())
{
var attachment = message.Attachments.FirstOrDefault(opt => opt.Type == AttachmentType.EncryptedMessage);
if (attachment != null)
{
var ecnryptedMessage = (EncryptedMessage)attachment.Payload;
saveMessageFlag = ecnryptedMessage.SaveFlag > 0;
}
}
List <MessageDto> newMessages = null;
if (saveMessageFlag)
{
newMessages = await createMessagesService.CreateDialogMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false);
}
else
{
var dialogs = await loadDialogsService.GetUsersDialogsAsync(message.SenderId.Value, message.ReceiverId.Value);
var senderMessage = MessageConverter.GetMessageDto(message);
senderMessage.ConversationId = dialogs.FirstOrDefault(dialog => dialog.FirstUserId == message.SenderId).Id;
var receiverMessage = MessageConverter.GetMessageDto(message);
receiverMessage.ConversationId = dialogs.FirstOrDefault(dialog => dialog.FirstUserId == message.ReceiverId).Id;
newMessages = new List <MessageDto> {
senderMessage, receiverMessage
};
}
newMessages.Reverse();
SendDialogNotificationsAsync(newMessages, saveMessageFlag);
}
catch (UserNotFoundException ex)
{
if (ex.UsersId != null)
{
var user = (await nodeRequestSender.GetUsersInfoAsync(
new List <long>(ex.UsersId),
null,
current).ConfigureAwait(false)).FirstOrDefault();
if (user != null)
{
await crossNodeService.NewOrEditUserAsync(new ShortUser
{
UserId = user.Id.GetValueOrDefault(),
}, current.Node.Id).ConfigureAwait(false);
}
List <MessageDto> newMessages = await createMessagesService.CreateDialogMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false);
newMessages.Reverse();
SendDialogNotificationsAsync(newMessages, saveMessageFlag);
}
}
}
}
public ConvertChannel(Fiber fiber, Channel <TOutput> output, MessageConverter <TInput, TOutput> converter)
{
_fiber = fiber;
Output = output;
Converter = converter;
}
public async Task <List <MessageDto> > GetByItem(Guid id)
{
var messages = _context.Messages.AsNoTracking().ToList().FindAll(x => x.ItemId == id);
return(MessageConverter.Convert(messages));
}
public void StringResponsesAreWrittenCorrectly()
{
var input = new MemoryStream();
var writer = new HmBinaryMessageWriter(input);
writer.BeginMessage(MessageType.Request);
writer.BeginContent();
writer.SetMethod("newDevices");
writer.BeginArray(1);
writer.BeginItem();
//parameter 1
writer.BeginArray(2);
writer.BeginItem();
writer.BeginStruct(2);
writer.BeginItem();
writer.WritePropertyName("CHILDREN");
var items = 3;
writer.BeginArray(items);
for (; items > 0; items--)
{
writer.BeginItem();
writer.WriteStringValue("value " + items);
writer.EndItem();
}
writer.EndArray();
writer.EndItem();
writer.BeginItem();
writer.WritePropertyName("FIRMWARE");
writer.WriteStringValue("1.505");
writer.EndItem();
writer.EndStruct();
writer.EndItem();
writer.BeginItem();
writer.BeginStruct(3);
writer.BeginItem();
writer.WritePropertyName("ADDRESS");
writer.WriteStringValue("BidCoS-RF");
writer.EndItem();
writer.BeginItem();
writer.WritePropertyName("CHILDREN");
var items2 = 5;
writer.BeginArray(items2);
for (; items2 > 0; items2--)
{
writer.BeginItem();
writer.WriteStringValue("value " + items2);
writer.EndItem();
}
writer.EndArray();
writer.EndItem();
writer.BeginItem();
writer.WritePropertyName("FIRMWARE");
writer.WriteStringValue("1.505");
writer.EndItem();
writer.EndStruct();
writer.EndItem();
//end parameter 1
writer.EndArray();
writer.EndItem();
//end params
writer.EndArray();
writer.EndContent();
writer.EndMessage();
var result = BinaryUtils.FormatMemoryStream(input);
input.Seek(0, SeekOrigin.Begin);
var converter = new MessageConverter();
var outputReader = new JsonMessageBuilder();
converter.Convert(new HmBinaryMessageReader(input), outputReader);
result.ShouldBe("42696E00000001180000000A6E6577446576696365730000000100000100000000020000010100000002000000084348494C4452454E0000010000000003000000030000000776616C75652033000000030000000776616C75652032000000030000000776616C75652031000000084649524D574152450000000300000005312E353035000001010000000300000007414444524553530000000300000009426964436F532D5246000000084348494C4452454E0000010000000005000000030000000776616C75652035000000030000000776616C75652034000000030000000776616C75652033000000030000000776616C75652032000000030000000776616C75652031000000084649524D574152450000000300000005312E353035");
}
