public async Task <IActionResult> AddUser(ChannelViewModel model)
        {
            model.MessageString = "test";
            if (ModelState.IsValid)
            {
                var chatroom = await _dbContext.Chatrooms
                               .Include(u => u.ChatroomMembers.UserChatroomMembers)
                               .ThenInclude(u => u.User)
                               .FirstOrDefaultAsync(c => c.Id == model.ChatroomId);

                var currentChatroomMembers = chatroom.ChatroomMembers;

                if (currentChatroomMembers != null)
                {
                    foreach (var member in model.ChatroomMembers)
                    {
                        var user = await _userManager.FindByNameAsync(member);

                        if (!currentChatroomMembers.UserChatroomMembers.Select(c => c.User).Contains(user))
                        {
                            var userChatroomMember = new UserChatroomMember
                            {
                                ChatroomMembers = currentChatroomMembers,
                                User            = user
                            };
                            currentChatroomMembers.UserChatroomMembers.Add(userChatroomMember);

                            var userwithUserRoomList = await _dbContext.Users
                                                       .Include(u => u.UserRoomList)
                                                       .ThenInclude(c => c.Chatroom.Messages)
                                                       .FirstOrDefaultAsync(u => u.Id == user.Id);

                            var userRoomList = new UserRoomList
                            {
                                Chatroom          = chatroom,
                                ChatroomId        = chatroom.Id,
                                ChatroomStatus    = 0,
                                ApplicationUserId = user.Id
                            };
                            if (user.UserRoomList != null)
                            {
                                if (!((userwithUserRoomList.UserRoomList.Any(c => c.ChatroomId == chatroom.Id)) &&
                                      (userwithUserRoomList.UserRoomList.Any(c => c.ApplicationUserId == user.Id))))
                                {
                                    await _dbContext.AddAsync(userRoomList);

                                    user.UserRoomList.Add(userRoomList);
                                    _dbContext.Update(user);
                                }
                            }
                        }
                    }

                    _dbContext.Update(currentChatroomMembers);
                    await _dbContext.SaveChangesAsync();
                }

                return(RedirectToAction("Channel", "Chatrooms", new { chatroom.Id }));
            }
            return(RedirectToAction("Channel", "Chatrooms", new { model.ChatroomId }));
        }
        public async Task <IActionResult> Channel(Guid id)
        {
            var currentUser = await _userManager.GetUserAsync(User);

            var userwithUserRoomList = await _dbContext.Users
                                       .Include(u => u.UserRoomList)
                                       .ThenInclude(c => c.Chatroom.Messages)
                                       .FirstOrDefaultAsync(u => u.Id == currentUser.Id);

            var currentChatroom = await _dbContext.Chatrooms
                                  .Include(u => u.ChatroomMembers.UserChatroomMembers)
                                  .ThenInclude(u => u.User)
                                  .FirstOrDefaultAsync(c => c.Id == id);

            var currentChatroomWithMembers = currentChatroom.ChatroomMembers.UserChatroomMembers.Select(u => u.User);

            if (currentChatroomWithMembers.Any(c => c.Id == currentUser.Id) == false)
            {
                var userChatroomMember = new UserChatroomMember
                {
                    ChatroomMembers = currentChatroom.ChatroomMembers,
                    User            = currentUser
                };
                await _dbContext.AddAsync(userChatroomMember);

                await _dbContext.SaveChangesAsync();
            }

            var userRoomList = new UserRoomList
            {
                Chatroom          = currentChatroom,
                ChatroomId        = id,
                ChatroomStatus    = 0,
                ApplicationUserId = currentUser.Id
            };

            if (currentUser.UserRoomList != null)
            {
                if (!((userwithUserRoomList.UserRoomList.Any(c => c.ChatroomId == currentChatroom.Id)) &&
                      (userwithUserRoomList.UserRoomList.Any(c => c.ApplicationUserId == currentUser.Id))))
                {
                    await _dbContext.AddAsync(userRoomList);

                    currentUser.UserRoomList.Add(userRoomList);
                    _dbContext.Update(currentUser);
                    await _dbContext.SaveChangesAsync();
                }
            }
            var customemodel = await _dbContext.Chatrooms
                               .Include(a => a.ChatroomMembers.UserChatroomMembers)
                               .ThenInclude(a => a.User)
                               .Include(chatroom => chatroom.Messages)
                               .Where(chatroom => chatroom.Id == id)
                               .Select(m => new ChannelViewModel
            {
                Chatroom   = m,
                ChatroomId = m.Id,
                UserId     = currentUser.Id
            }).FirstOrDefaultAsync();

            var users = _userManager.Users;

            ViewBag.Users = users.Select(x =>
                                         new SelectListItem()
            {
                Text  = x.UserName,
                Value = x.ToString()
            });
            ViewBag.UserRoomList = await _dbContext.Users
                                   .Include(u => u.UserRoomList)
                                   .ThenInclude(c => c.Chatroom.Messages)
                                   .Where(c => c.UserRoomList
                                          .Any(u => u.ApplicationUserId == currentUser.Id))
                                   .FirstOrDefaultAsync(u => u.Id == currentUser.Id);

            return(View(customemodel));
        }
        public async Task <IActionResult> Create(CreateChatroomViewModel model)
        {
            if (ModelState.IsValid)
            {
                if (_dbContext.Chatrooms.Any(c => c.ChatroomName == model.ChatroomName))
                {
                    ModelState.AddModelError("", "An Chatroom with this Name allready exists");
                    var users = _userManager.Users;
                    ViewBag.Users = users.Select(x =>
                                                 new SelectListItem()
                    {
                        Text  = x.UserName,
                        Value = x.ToString()
                    });
                    return(View(model));
                }
                var currentUser = await _userManager.GetUserAsync(User);

                var chatroom = new Chatroom
                {
                    ChatroomName       = model.ChatroomName,
                    ChatroomTopic      = model.ChatroomTopic,
                    ChatroomDesription = model.ChatroomDesription,
                    Password           = model.Password,
                    Private            = model.Private,
                    ChatroomMembers    = new ChatroomMembers()
                };
                if (currentUser != null)
                {
                    var chatroomMembers = new ChatroomMembers
                    {
                        ChatroomId          = chatroom.Id,
                        UserChatroomMembers = new List <UserChatroomMember>()
                    };
                    var currentuserChatroomMember = new UserChatroomMember
                    {
                        ChatroomMembers = chatroomMembers,
                        User            = currentUser
                    };
                    chatroomMembers.UserChatroomMembers.Add(currentuserChatroomMember);

                    if (model.ChatroomMembers != null)
                    {
                        foreach (var member in model.ChatroomMembers)
                        {
                            var user = await _userManager.FindByNameAsync(member);

                            if (!chatroomMembers.UserChatroomMembers.Select(c => c.User).Contains(user))
                            {
                                var userChatroomMember = new UserChatroomMember
                                {
                                    ChatroomMembers = chatroomMembers,
                                    User            = user
                                };
                                chatroomMembers.UserChatroomMembers.Add(userChatroomMember);
                            }
                        }
                    }
                    _dbContext.Add(chatroom);
                    await _dbContext.SaveChangesAsync();

                    _dbContext.Add(chatroomMembers);
                    await _dbContext.SaveChangesAsync();


                    var userwithUserRoomList = await _dbContext.Users
                                               .Include(u => u.UserRoomList)
                                               .ThenInclude(c => c.Chatroom.Messages)
                                               .FirstOrDefaultAsync(u => u.Id == currentUser.Id);

                    var userRoomList = new UserRoomList
                    {
                        Chatroom          = chatroom,
                        ChatroomId        = chatroom.Id,
                        ChatroomStatus    = 0,
                        ApplicationUserId = currentUser.Id
                    };
                    if (currentUser.UserRoomList != null)
                    {
                        if (!((userwithUserRoomList.UserRoomList.Any(c => c.ChatroomId == chatroom.Id)) &&
                              (userwithUserRoomList.UserRoomList.Any(c => c.ApplicationUserId == currentUser.Id))))
                        {
                            await _dbContext.AddAsync(userRoomList);

                            currentUser.UserRoomList.Add(userRoomList);
                            _dbContext.Update(currentUser);
                            await _dbContext.SaveChangesAsync();
                        }
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            var currentuser = _userManager.Users;

            ViewBag.Users = currentuser.Select(x =>
                                               new SelectListItem()
            {
                Text  = x.UserName,
                Value = x.ToString()
            });
            ModelState.AddModelError("", "Something went wrong try again");
            return(View(model));
        }