public async Task SendMessage(SendMessageModel message)
{
ReceiveMessageModel response = null;
MessageModel msg = new MessageModel
{
UserName = message.UserName,
Message = message.Message,
RoomCode = message.RoomCode,
CreatedDate = DateTime.Now
};
MessageModel responseMsg = await _chatRepository.AddAsync(msg);
response = new ReceiveMessageModel
{
UserName = responseMsg.UserName,
Message = responseMsg.Message,
RoomCode = responseMsg.RoomCode,
CreateDate = responseMsg.CreatedDate
};
if (response != null)
{
await Clients.Group(message.RoomCode).SendAsync("ReceiveMessage", response);
}
}
public async Task <ChatResponse> SaveAsync(Chat chat, int user1Id, int user2Id)
{
var existingUser1 = await _userRepository.FindById(user1Id);
if (existingUser1 == null)
{
return(new ChatResponse("User not found"));
}
var existingUser2 = await _userRepository.FindById(user2Id);
if (existingUser2 == null)
{
return(new ChatResponse("User not found"));
}
chat.User1 = existingUser1;
chat.User2 = existingUser2;
try
{
await _chatRepository.AddAsync(chat);
return(new ChatResponse(chat));
}
catch (Exception ex)
{
return(new ChatResponse(
$"An error ocurred while saving the Message: {ex.Message}"));
}
}
//public async Task<Chat> GetChatByPartijId(int partijId)
//{
// return await _unitOfWork.Chats
// .GetChatByPartijId(partijId);
//}
public async Task <Chat> CreateChat(Chat newChat)
{
await _chatRepository.AddAsync(newChat);
await _chatRepository.CommitAsync();
return(newChat);
}
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 <Chat> AddMessageGroup(int roomid, string message, int userid)
{
try
{
var project = await _projectRepository.FindAll().FirstOrDefaultAsync(x => x.Room.Equals(roomid));
var managers = await _manageRepository.FindAll().Where(x => x.ProjectID.Equals(project.ID)).Select(x => x.UserID).ToListAsync();
var members = await _teamMemberRepository.FindAll().Where(x => x.ProjectID.Equals(project.ID)).Select(x => x.UserID).ToListAsync();
var listAll = managers.Union(members);
var listChats = new List <Chat>();
var listParticipants = new List <Participant>();
//Neu chua co participan thi them vao
if (!await _participantRepository.FindAll().AnyAsync(x => x.RoomID == roomid))
{
foreach (var user in listAll)
{
listParticipants.Add(new Participant
{
UserID = user,
RoomID = roomid
});
}
await _unitOfWork.Commit();
}
var chat = new Chat
{
Message = message,
UserID = userid,
ProjectID = project.ID,
RoomID = roomid
};
//add message userid
await _chatRepository.AddAsync(chat);
await _unitOfWork.Commit();
await _hubContext.Clients.Group(chat.RoomID.ToString()).SendAsync("ReceiveMessageGroup", chat.RoomID.ToInt());
return(chat);
}
catch (Exception ex)
{
return(new Chat());
throw;
}
throw new NotImplementedException();
}
public async Task <ChatResponse> SaveAsync(Chat chat)
{
try
{
await _chatRepository.AddAsync(chat);
await _unitOfWork.CompleteAsync();
return(new ChatResponse(chat));
}
catch (Exception e)
{
return(new ChatResponse($"An error ocurred while saving the Chat: {e.Message}"));
}
}
public async Task <IActionResult> SendRequest([FromBody] MessageDTO message)
{
var chatMessage = new ChatModel()
{
Id = message.Id,
FromUser = message.FromUser,
ToUser = message.ToUser,
CreationDate = message.CreationDate,
LastEditDate = message.LastModifiedDate,
Message = message.Message,
IsOnline = message.IsOnline
};
await _chatRepository.AddAsync(chatMessage);
await _hubContext.Clients.All.SendAsync("OnReceive", message);
return(Ok());
}
public async Task <ChatResponse> SaveAsync(Chat chat)
{
try
{
var searchTo = await _clientRepository.FindByIdAsync(chat.To);
if (searchTo == null)
{
return(new ChatResponse($"(to)Client {chat.To} not found"));
}
var searchFrom = await _clientRepository.FindByIdAsync(chat.From);
if (searchFrom == null)
{
return(new ChatResponse($"(from)Client {chat.From} not found"));
}
var searchFromChat = await _chatRepository.FindByFromAsync(chat.From);
var searchToChat = await _chatRepository.FindByToAsync(chat.To);
if (searchFromChat != null && searchToChat != null)
{
return(new ChatResponse($"This chat already (from){chat.From} and (to){chat.To} exist "));
}
await _chatRepository.AddAsync(chat);
await _unitOfWork.CompleteAsync();
return(new ChatResponse(chat));
}
catch (Exception e)
{
return(new ChatResponse($"An error occurred when saving the chat: {e.Message}"));
}
}
public async Task <ChatResponse> SaveAsync(int senderId, int receiverId, int petId)
{
var existingSender = await _profileRepository.FindByIdAsync(senderId);
var existingReceiver = await _profileRepository.FindByIdAsync(receiverId);
var existingPet = await _petProfileRepository.FindById(petId);
bool attended = false;
if (existingSender == null)
{
return(new ChatResponse("Sender not found"));
}
if (existingReceiver == null)
{
return(new ChatResponse("Receiver not found"));
}
if (existingPet == null)
{
return(new ChatResponse("Pet not found"));
}
var possibleOwner1 = await _petOwnerRepository.FindByPetIdAndOwnerId(petId, senderId);
var possibleOwner2 = await _petOwnerRepository.FindByPetIdAndOwnerId(petId, receiverId);
if (possibleOwner1 == null && possibleOwner2 == null)
{
return(new ChatResponse("Pet not associated with the owner"));
}
try
{
bool exist = false;
IEnumerable <Chat> chatsReceiver = await _chatRepository.ListBySenderId(receiverId);
if (chatsReceiver != null)
{
chatsReceiver.ToList().ForEach(chat => {
if (chat.ReceiverProfileId == senderId && chat.PetId == petId)
{
exist = true;
}
});
}
Chat chat = new Chat();
if (!exist)
{
chat.ReceiverProfileId = senderId;
chat.SenderProfileId = receiverId;
chat.PetId = petId;
await _chatRepository.AddAsync(chat);
await _unitOfWork.CompleteAsync();
}
chat.ReceiverProfileId = receiverId;
chat.SenderProfileId = senderId;
chat.PetId = petId;
await _chatRepository.AddAsync(chat);
await _unitOfWork.CompleteAsync();
return(new ChatResponse(chat));
}
catch (Exception ex)
{
return(new ChatResponse($"An error ocurred while saving chat: {ex.Message}"));
}
}
