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));
}