public async Task <MessageResponse> SaveAsync(int senderId, Message message) { var existingSenderChat = await _chatRepository.FindById(senderId); if (existingSenderChat == null) { return(new MessageResponse("Chat ot found")); } try { IEnumerable <Chat> chats = await _chatRepository.ListBySenderId(existingSenderChat.ReceiverProfileId); int receiverId = 0; chats.ToList().ForEach(chat => { if (chat.ReceiverProfileId == senderId && existingSenderChat.PetId == chat.PetId) { receiverId = chat.Id; } }); if (receiverId == 0) { Chat chat = new Chat { SenderProfileId = existingSenderChat.ReceiverProfileId, ReceiverProfileId = existingSenderChat.SenderProfileId, PetId = existingSenderChat.PetId }; await _chatRepository.AddAsync(chat); await _unitOfWork.CompleteAsync(); receiverId = chat.Id; } message.ChatId = receiverId; await _messageRepository.AddAsync(message); await _unitOfWork.CompleteAsync(); message.ChatId = existingSenderChat.ReceiverProfileId; await _messageRepository.AddAsync(message); await _unitOfWork.CompleteAsync(); return(new MessageResponse(message)); } catch (Exception ex) { return(new MessageResponse($"An error ocurred while saving message: {ex.Message}")); } }
public async Task StartAsync(CancellationToken cancellationToken) { string clientId = $"producer-{Guid.NewGuid().ToString()}"; StanOptions stanOptions = StanOptions.GetDefaultOptions(); stanOptions.NatsURL = _natsOptions.Url; using (var c = new StanConnectionFactory() .CreateConnection(_natsOptions.ClusterId, clientId, stanOptions)) { while (!cancellationToken.IsCancellationRequested) { var message = new Message(); await _messageRepository.AddAsync(message); var json = JsonSerializer.Serialize(message); Console.WriteLine($"Отправка {json}"); c.Publish(_natsOptions.Subject, Encoding.UTF8.GetBytes(json)); await Task.Delay(1000); } _logger.LogInformation("Отправка сообщений отменена."); } }
public async Task SendToRoom(string roomName, string message) { try { var user = _iAccountRepository.All.FirstOrDefault(u => u.Email == IdentityName); var room = _iRoomRepository.All.FirstOrDefault(r => r.Name == roomName); if (!string.IsNullOrEmpty(message.Trim())) { var msg = new Message() { Content = Regex.Replace(message, @"(?i)<(?!img|a|/a|/img).*?>", string.Empty), FromUser = user, ToRoom = room, Timestamp = DateTime.Now }; await _iMessageRepository.AddAsync(msg); await _iMessageRepository.SaveAsync(); var messageViewModel = _mapper.Map <Message, MessageViewModel>(msg); await Clients.Group(roomName).SendAsync("newMessage", messageViewModel); } } catch (Exception) { await Clients.Caller.SendAsync("onError", "Message not send! Message should be 1-500 characters."); } }
public async Task StartAsync(string consumerId) { StanOptions options = StanOptions.GetDefaultOptions(); options.NatsURL = _natsOptions.Url; var stanSubOptions = StanSubscriptionOptions.GetDefaultOptions(); stanSubOptions.DurableName = _natsOptions.DurableName; _stanConnection = new StanConnectionFactory() .CreateConnection(_natsOptions.ClusterId, consumerId, options); try { _stanConnection .Subscribe(_natsOptions.Subject, stanSubOptions, (obj, args) => { string messageData = Encoding.UTF8.GetString(args.Message.Data); Console.WriteLine($"[#{args.Message.Sequence}] {messageData}"); var message = JsonSerializer.Deserialize <Message>(messageData); message.Number = args.Message.Sequence; _messageRepository.AddAsync(message).GetAwaiter().GetResult(); }); } catch (Exception e) { _logger.LogError($"Ошибка подписки на сообщения: {e.ToString()}"); CloseConnection(); } await Task.CompletedTask; }
public async Task <Message> IndexMessage(Message message) { message = await _messageRepository.AddAsync(message); IndexToFeed(message); // IDEALLY SHOULD HAPPEN OFFLINE - NOT ON REALTIME return(message); }
public async Task <OperationResult> AddMessage(int currentUserId, MessagePostDto message) { var messageModel = new Message() { Content = message.Content, DateCreated = DateTime.Now, IsDelivered = false, ReceiverId = message.ReceiverId, SenderId = currentUserId }; await repository.AddAsync(messageModel); var response = await repository.SaveChangesAsync(); if (response > 0) { return(new OperationResult() { IsSuccessful = true, Payload = messageModel }); } else { return(OtherServices.GetIncorrectDatabaseConnectionResult()); } }
public async Task HandleAsync(SendMessageCommand command) { var conversation = await _conversationRepository.GetAsync(new ConversationId(command.ConversationId)); var message = conversation.Send(MessageId.From(command.MessageId), new MessageBody(command.Text), new Participant(command.SenderId), _clock); await _messageRepository.AddAsync(message); }
//[ValidateAntiForgeryToken] public async Task <IActionResult> Upload([FromForm] UploadViewModel uploadViewModel) { if (ModelState.IsValid) { if (!Validate(uploadViewModel.File)) { return(BadRequest("Validation failed!")); } var fileName = DateTime.Now.ToString("yyyymmddMMss") + "_" + Path.GetFileName(uploadViewModel.File.FileName); var folderPath = Path.Combine(_environment.WebRootPath, "uploads"); var filePath = Path.Combine(folderPath, fileName); if (!Directory.Exists(folderPath)) { Directory.CreateDirectory(folderPath); } using (var fileStream = new FileStream(filePath, FileMode.Create)) { await uploadViewModel.File.CopyToAsync(fileStream); } var user = await _accountRepository.All.FirstOrDefaultAsync(u => u.Email == HttpContext.Session.GetString(SessionName)); var room = await _roomRepository.All.FirstOrDefaultAsync(r => r.Id == uploadViewModel.RoomId); if (user == null || room == null) { return(NotFound()); } string htmlImage = string.Format( "<a href=\"/uploads/{0}\" target=\"_blank\">" + "<img src=\"/uploads/{0}\" class=\"post-image\">" + "</a>", fileName); var message = new Message() { Content = Regex.Replace(htmlImage, @"(?i)<(?!img|a|/a|/img).*?>", string.Empty), Timestamp = DateTime.Now, FromUser = user, ToRoom = room }; await _messageRepository.AddAsync(message); await _messageRepository.SaveAsync(); // Send image-message to group var messageViewModel = _mapper.Map <Message, MessageViewModel>(message); await _hubContext.Clients.Group(room.Name).SendAsync("newMessage", messageViewModel); return(Ok()); } return(BadRequest()); }
public async Task <Message> AddMessageAsync(dynamic newMessage) { Message m = new Message() { CreatedBy = newMessage.CreatedBy, DateCreated = DateTime.Now, MessageBody = newMessage.MessageBody, StatusTypeId = (int)EnumMessageStatusType.Sent }; return(await _messageRepository.AddAsync(m)); }
public async Task <bool> AddAsync(MessagePostDto entity, string senderId) { try { return(await _messageRepository.AddAsync(entity, senderId)); } catch (DataException) { throw; } }
public async Task OnMessageCreateAsync(Message message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } await _messageRepository.AddAsync(message); message = await _messageRepository.GetByIdAsync(message.Id); await NotifyClients(message.Chat.Id, client => client.onMessageCreateAsync(message)); }
public async Task <SendMsgDTO> GetReplyMessageAsync(Guid senderId, Guid replyToMessageId) { try { var replyToMessage = await _messageRepository .GetAsync(replyToMessageId); var message = new Message() { CreatedById = senderId, MessageCode = await GenerateMessageCodeAsync(), Subject = $"پاسخ به نامه {replyToMessage.MessageNumber}", // TODO MessageNumber = null, }; var t1 = _messageRepository.AddAsync(message); var sender = new MessageSender() { UserId = senderId, MessageId = message.Id, ReplyToId = message.Id, Message = message, }; var t2 = _messageSenderRepository.AddAsync(sender); var reciever = new MessageReciever() { IsCc = false, MessageId = message.Id, MessageSenderId = sender.Id, UserId = message.CreatedById, }; var t3 = _messageRecieverRepository.AddAsync(reciever); Task.WaitAll(t1, t2, t3); await _unitOfWork.SaveAsync(); var replyMessageDto = new SendMsgDTO(); _mapper.Map(message, replyMessageDto); replyMessageDto.MessageSendersId = sender.Id; return(replyMessageDto); } catch (Exception e) { throw; } }
public async Task <IEnumerable <MessageViewModel> > AddMember(AddMemberRequest request) { var conversation = await conversationRepository.GetByIdAsync(ObjectId.Parse(request.ConversationId)); var currentUser = Feature.CurrentUser(httpContextAccessor, userRepository); var currentMember = conversation.Participants.FirstOrDefault(x => x.MemberId == currentUser.OId); if (currentMember.Role != ConversationRole.Admin) { throw new Exception("Bạn không có quyền thêm người dùng mới vào cuộc trò chuyện. "); } var result = new List <Message>(); foreach (var userId in request.UserIds) { if (conversation.Participants.FirstOrDefault(x => x.MemberId == userId) == null) { var user = await userRepository.GetByIdAsync(ObjectId.Parse(userId)); var conversationMember = new ConversationMember() { MemberId = user.OId, DateJoin = DateTime.Now, JoinBy = currentUser.OId, Nickname = $"{user.FirstName} {user.LastName}", Role = ConversationRole.Admin }; conversation.Participants.Add(conversationMember); await conversationRepository.UpdateAsync(conversation, conversation.Id); var message = new Message() { SenderId = currentUser.OId, ConversationId = conversation.OId, StringContent = $"{user.FirstName} {user.LastName} đã được thêm vào nhóm", Status = ItemStatus.Active, IsEdited = false, CreatedDate = DateTime.Now, ModifiedDate = DateTime.Now }; await messageRepository.AddAsync(message); result.Add(message); } } return(mapper.Map <IEnumerable <MessageViewModel> >(result)); }
public async Task HandleAsync(SendMessageCommand command) { var group = await _groupRepository.GetAsync(GroupId.From(command.GroupId)) ?? throw new GroupNotFoundException(GroupId.From(command.GroupId)); var channel = await _channelRepository.GetAsync(group.Id, ChannelId.From(command.ChannelId)) ?? throw new ChannelNotFoundException(ChannelId.From(command.ChannelId)); if (await _messageRepository.ExistsAsync(ChannelId.From(command.ChannelId), MessageId.From(command.MessageId))) { throw new MessageAlreadyExistsException(command.MessageId); } var message = group.SendMessage(UserId.From(command.UserId), channel, MessageId.From(command.MessageId), MessageContent.Create(command.Content), _clock); await _messageRepository.AddAsync(message); }
public async Task <bool> SendMessage(SendMessageApiModel createMessageApiModel) { var isSenderBlocked = await _userService.IsSenderBlockedByReceiver(createMessageApiModel.SenderUserId, createMessageApiModel.ReceiverUserId); if (isSenderBlocked) { throw new MessagingDomainException("Can't send message, sender is blocked by receiver."); } var entity = new Message(createMessageApiModel.SenderUserId, createMessageApiModel.ReceiverUserId, createMessageApiModel.MessageText); await _repository.AddAsync(entity); return(await _repository.UnitOfWork.CommitAsync()); }
public async Task <MessageViewModel> Handle(CreateMessageCommand request, CancellationToken cancellationToken = default) { var message = new Message(request.Message, _dateTimeOffset.Now); var messageResult = await _messageRepository.AddAsync(message); var viewModel = new MessageViewModel { Id = messageResult.Id, Content = messageResult.Content, Timestamp = messageResult.Timestamp }; return(viewModel); }
public async Task <MessageResponse> SaveAsync(Message message, int freelancerId, int employerId) { try { await _messageRepository.AddAsync(message); await _unitOfWork.CompleteAsync(); return(new MessageResponse(message)); } catch (Exception ex) { return(new MessageResponse($"An error ocurred while saving the message: {ex.Message}")); } }
/// <inheritdoc /> public virtual void Handle(IMessageContext messageContext) { if (!Active) { return; } MessageRecord messageRecord = null; var convertPipeline = messageContext.Pipeline as IMessageRecordConverter; if (convertPipeline != null) { messageRecord = convertPipeline.CreateMessageRecord(messageContext); } else { messageRecord = MessageRecordHelpers.Create(messageContext); } if (filter != null && !filter.IsMatch(messageRecord)) { return; } try { repository.AddAsync(messageRecord, CancellationToken.None).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception) { if (RethrowExceptions) { throw; } } }
public async void PromoverAppointment(Patient Patient) { var result = await dialogService.DisplayActionSheetAsync("Selecione a operação desejada para o pedido de interconsulta", "Cancelar", null, "Aceitar", "Negar"); var action = Patient.ActionCollection.FirstOrDefault(x => x.Id == Action.Id); switch (result) { case "Aceitar": action.IsRelease = false; action.IsAppointment = true; action.IsListWaiting = false; action.IsInterconsultationtion = false; await patientRepository.AddOrUpdateAsync(Patient, Patient.Id); await navigationService.GoBackAsync(); return; case "Negar": Responsible responsible = await responsibleRepository.GetAsync(Settings.UserId); Message message = new Message { Date = DateTime.Now, IdAction = Action.Id, IdFrom = Settings.UserId, NameFrom = responsible.NameCompleto, IdTo = action.ProfessorIdFrom, Body = "Recusou o pedido de interconsulta para o paciente " + Patient.NameCompleto + ", para a ação " + Action.Name }; await messageRepository.AddAsync(message); Patient.ActionCollection.Remove(action); await patientRepository.AddOrUpdateAsync(Patient, Patient.Id); await navigationService.GoBackAsync(); break; } }
public async Task <MessageResponse> SaveAsync(Message messageObj) { try { var search = await _chatRepository.FindByIdAsync(messageObj.ChatId); if (search == null) { return(new MessageResponse($"Chat {messageObj.ChatId} not found")); } var connection = EnumExtensions.FactoryConfig.CreateConnection(); using (var channel = connection.CreateModel()) { channel.QueueDeclare(queue: $"message_C{messageObj.ChatId}", durable: false, exclusive: false, autoDelete: false, arguments: null); string message = JsonSerializer.Serialize(messageObj); var body = Encoding.UTF8.GetBytes(message); channel.BasicPublish(exchange: "", routingKey: $"message_C{messageObj.ChatId}", basicProperties: null, body: body); } await _messageRepository.AddAsync(messageObj); await _unitOfWork.CompleteAsync(); return(new MessageResponse(messageObj)); } catch (Exception e) { return(new MessageResponse($"An error occurred when saving the message: {e.Message}")); } }
public async Task <MessageResponse> SaveAsync(Message message, int ChatId, int userId) { var existingUser = await _userRepository.FindById(userId); if (existingUser == null) { return(new MessageResponse("User not found")); } message.User = existingUser; try { await _messageRepository.AddAsync(message); return(new MessageResponse(message)); } catch (Exception ex) { return(new MessageResponse( $"An error ocurred while saving the Message: {ex.Message}")); } }
public async void PromoverInterconsultationtion(ActionModel actionDestino) { if (Patient.ActionCollection.FirstOrDefault(x => x.Id == actionDestino.Id) == null) { Patient.ActionCollection.Add(new ListAppointment { Id = actionDestino.Id, ProfessorIdFrom = Settings.UserId, Name = actionDestino.Name, Added = true, IsRelease = false, IsAppointment = false, IsListWaiting = false, IsInterconsultationtion = true }); Responsible responsible = await responsibleRepository.GetAsync(Settings.UserId); Message message = new Message { Date = DateTime.Now, IdAction = Action.Id, IdFrom = Settings.UserId, NameFrom = responsible.NameCompleto, Body = "Enviou um pedido de interconsulta para o paciente " + Patient.NameCompleto + ", para a ação " + Action.Name }; await messageRepository.AddAsync(message); await patientRepository.AddOrUpdateAsync(Patient, Patient.Id); await navigationService.GoBackAsync(); } else { await MessageService.Instance.ShowAsync("Este usuário já está na ação " + actionDestino.Name); } }
public async Task AddMessageAsync(Message message) { message.Content = message.Content.Trim().TrimEnd(new char[] { '\r', '\n', }); await _messageRepository.AddAsync(message); }
/// <summary> /// 新增消息 /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <bool> Handle(CreateMessageCommand request, CancellationToken cancellationToken) { await _messageRepository.AddAsync(new Domain.Message(request.Title, request.Content, request.Type, request.SenderID, request.SenderName, request.UserList)); return(true); }
public async Task <Message> CreateMessageAsync(Message message) { var addedMessage = await _messageRepository.AddAsync(message); return(addedMessage); }
public async Task <Message> SendMessageAsync(Message message) { return(await messageRepository.AddAsync(message)); }