public async Task <IActionResult> CreateChat([FromBody] ChatCreateDto chatCreateDto)
{
var user = _unitOfWork.Users.GetByID(chatCreateDto.OwnerId);
if (user == null)
{
return(NotFound());
}
var chat = new Chat
{
Name = chatCreateDto.Name,
IsGroupChat = true,
Owner = user
};
var userChat = new UsersChats
{
User = user,
Chat = chat
};
chat.UsersChats.Add(userChat);
await _chatsManager.CreateChatAsync(chat);
return(Created("", chatCreateDto));
}
public async Task AddUserToChatAsync(int chatId, string userId)
{
var chat = _unitOfWork.Chats.GetByID(chatId);
var userToAdd = _unitOfWork.Users.GetByID(userId);
var userChat = new UsersChats()
{
Chat = chat,
User = userToAdd
};
_unitOfWork.UsersChats.Insert(userChat);
_unitOfWork.SaveChanges();
var chatReadDto = _mapper.Map <ChatReadDto>(chat);
var chatReadDtoString = JsonConvert.SerializeObject(chatReadDto, _settings);
var userChatDto = _mapper.Map <UsersChatsDto>(userChat);
var userChatDtoString = JsonConvert.SerializeObject(userChatDto, _settings);
foreach (var user in chat.UsersChats.Select(uc => uc.User))
{
if (_connectedUsers.ContainsKey(user))
{
if (user == userToAdd)
{
await _hub.Clients.Client(_connectedUsers[user]).SendAsync("NewChatCreated", chatReadDtoString);
}
await _hub.Clients.Client(_connectedUsers[user]).SendAsync("UserAddedToChat", userChatDtoString, chatId);
}
}
}
/// <summary>
/// Returns List of all chats belongs to the current user
/// </summary>
/// <returns>List of all chats</returns>
public async Task <IEnumerable <Chat> > GetAllChatsAsync()
{
var chats = await UsersChats
.Where(uc => uc.User.Id == CurrentUser.Id)
.Select(uc => uc.Chat)
.OrderBy(c => c.ModifyDate).ToListAsync();
return(chats);
}
private async Task <UsersChats> GetUsersChatsAsync(string chatId)
{
var Uc = await UsersChats
.Include(uc => uc.Chat)
.Include(uc => uc.User)
.SingleOrDefaultAsync(uc => uc.Chat.Id == chatId && (uc.UserId == CurrentUser.Id || uc.Chat.ChatType == ChatType.ChatRoom));
return(Uc);
}
public async Task <IActionResult> AddFriend([FromBody] AddFriendDto addFriendDto)
{
var currentUser = await _signInManager.UserManager.GetUserAsync(User);
var user = _unitOfWork.Users.GetByID(addFriendDto.UserId);
if (user == null)
{
return(BadRequest());
}
if (currentUser.Id != user.Id)
{
return(Unauthorized());
}
var friend = _unitOfWork.Users.GetByName(addFriendDto.FriendsName);
if (friend == null)
{
return(NotFound());
}
if (user == friend)
{
return(BadRequest());
}
bool result = await _friendsManager.AddFriendAsync(user, friend);
if (result)
{
var chat = new Chat()
{
IsGroupChat = false
};
var userChats1 = new UsersChats()
{
User = user,
Chat = chat
};
var userChats2 = new UsersChats()
{
User = friend,
Chat = chat
};
chat.UsersChats.Add(userChats1);
chat.UsersChats.Add(userChats2);
await _chatsManager.CreateChatAsync(chat);
return(Created("", addFriendDto));
}
else
{
return(NotFound());
}
}
/// <summary>
/// Gets all chats with specific user if there are any chat, else will return null
/// </summary>
/// <param name="withUserId"></param>
/// <returns></returns>
public async Task <IEnumerable <Chat> > GetAllChatWithAsync(string withUserId)
{
var withUser = Users.Find(withUserId);
if (withUser == null)
{
return(null);
}
var chats = (await UsersChats.Where(u => u.UserId == withUserId)
.Select(u => u.Chat).ToListAsync())
.Intersect(await GetAllChatsAsync());
return(chats);
}
public async Task <Chat> GetChatByIdAsync(string chatId)
{
var chat = (await GetUsersChatsAsync(chatId)).Chat;
if (chat == null)
{
return(null);
}
if (chat.ChatType != ChatType.ChatRoom)
{
chat.UsersChats = await UsersChats.Include(uc => uc.User).Where(uc => uc.ChatId == chatId).ToListAsync();
chat.Messages = await GetMessagesAsync(chatId);
}
return(chat);
}
/// <summary>
/// Converts there isRead value to true
/// </summary>
/// <param name="chatId"></param>
/// <param name="messageIds"></param>
public async Task <bool> ReadChatAsync(string chatId)
{
var x = CurrentUser.UsersChats.SingleOrDefault(c => c.Chat.Id == chatId);
if (x == null)
{
return(false);
}
x.UnReadMessagesCount = 0;
x.IsRead = true;
UsersChats.Attach(x);
Db.Entry(x).State = EntityState.Modified;
await Db.SaveChangesAsync();
return(true);
}
/// <summary>
/// Gets chat with specific user if the chat if exist, else will return null
/// </summary>
/// <param name="withUserId"></param>
/// <returns></returns>
public async Task <Chat> GetChatWithAsync(string withUserId)
{
var withUser = Users.Find(withUserId);
if (withUser == null)
{
return(null);
}
var chat = await UsersChats
.Where(uc => uc.UserId == withUserId).Include(uc => uc.User)
.Select(uc => uc.Chat).Include(c => c.UsersChats)
.SingleOrDefaultAsync(c =>
c.ChatType == ChatType.Personal &&
c.UsersChats.SingleOrDefault(u => u.UserId == CurrentUser.Id) != null);
return(chat);
}
/// <summary>
/// Accept a specific friend request
/// </summary>
/// <param name="id">The specific friend Id</param>
public async Task <User> AcceptAddFriendRequestAsync(string requestId)
{
var request = await RemoveFriendRequestByIdAsync(requestId);
var user = request?.ToUserId == CurrentUser.Id ? request.FromUser:null;
if (user == null)
{
return(null);
}
var chat = new Chat()
{
CreatedByUser = CurrentUser,
ChatType = ChatType.Personal
};
var uc = new List <UsersChats>()
{
new UsersChats {
Chat = chat, User = CurrentUser, Rools = UserChatRools.Admin
},
new UsersChats {
Chat = chat, User = user, Rools = UserChatRools.Admin
}
};
chat.UsersChats = uc;
(await Chats.AddAsync(chat)).State = EntityState.Added;
await UsersChats.AddRangeAsync(uc);
var friends = new Friends()
{
FromUser = user, ToUser = CurrentUser, Chat = chat
};
(await Friends.AddAsync(friends)).State = EntityState.Added;
await Db.SaveChangesAsync();
return(user);
}
public async Task <bool> AddToChatGroupAsync(string chatId, string userId)
{
var uc = await GetUsersChatsAsync(chatId);
var user = Users.Find(userId);
if (uc != null && uc.Rools == UserChatRools.Admin && user != null)
{
UsersChats.Add(new UsersChats()
{
ChatId = uc.ChatId,
Rools = UserChatRools.User,
UserId = userId
}).State = EntityState.Added;
await Db.SaveChangesAsync();
return(true);
}
return(false);
}
private async Task <Chat> CreateChatAsync(ChatType type, User[] withUsers = null, Chat chat = null)
{
if (withUsers?.Length == 1 && type == ChatType.Personal)
{
var existChat = await GetChatWithAsync(withUsers.First().Id);
if (existChat != null)
{
return(existChat);
}
}
chat = new Chat()
{
Name = chat?.Name,
CreatedByUser = CurrentUser,
ChatType = chat?.ChatType ?? type
};
bool isCurrentUserAdded = false;
if (withUsers != null)
{
foreach (var user in withUsers)
{
if (withUsers.Length == 1)
{
chat.UsersChats.Add(new UsersChats()
{
Chat = chat, User = user, Rools = UserChatRools.Admin
});
break;
}
isCurrentUserAdded = (user.Id == CurrentUser.Id);
if (isCurrentUserAdded)
{
chat.UsersChats.Add(new UsersChats()
{
Chat = chat, User = user, Rools = UserChatRools.Admin
});
}
chat.UsersChats.Add(new UsersChats()
{
Chat = chat, User = user, Rools = UserChatRools.User
});
}
}
if (!isCurrentUserAdded)
{
chat.UsersChats.Add(new UsersChats()
{
Chat = chat, User = CurrentUser, Rools = UserChatRools.Admin
});
}
var entityEntryChat = await Chats.AddAsync(chat);
entityEntryChat.State = EntityState.Added;
UsersChats.AddRange(chat.UsersChats);
//if the problem not solved must separate the UsersChats collection and add it later after saveChages for adding the chat
// be cause the UsersChats elements has a references to the chat
await Db.SaveChangesAsync();
return(entityEntryChat.Entity);
}
