예제 #1
0
        public List <UserGroup> GetAllUserGroups()
        {
            var type = "A";

            try
            {
                UserGroupMapper objUsrMapper = new UserGroupMapper();
                SqlParameter[]  parameters   =
                {
                    new SqlParameter("@Type", type)
                };
                IDataReader reader = base.GetReader("SP_Manage_UserGroup", parameters);
                using (reader)
                {
                    return(objUsrMapper.Map(reader));
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
        public async Task AddUserToGroupAsync(int groupId, string currentUserId, List <CreateUserAC> user)
        {
            List <Activity> activityList = new List <Activity>();
            List <Friend>   friendList   = await _context.Friends.Where(u => u.UserID.Equals(currentUserId) || u.FriendID.Equals(currentUserId)).ToListAsync();

            List <Friend> newFriend = new List <Friend>();
            string        group     = await _context.Groups.Where(g => g.ID == groupId).Select(g => g.Name).FirstOrDefaultAsync();

            var groupUsers = await _context.UserGroupMappers.Where(u => u.GroupID == groupId).ToListAsync();


            for (int i = 0; i < user.Count; i++)
            {
                var allUsers = await _context.Users.Select(u => u.UserName).ToListAsync();

                var newUsers = new UserGroupMapper();

                var newUser = new ApplicationUser
                {
                    FullName = user[i].FullName,
                    UserName = user[i].UserName
                };

                if (allUsers.Contains(user[i].UserName.ToLower()))
                {
                    newUsers.GroupID = groupId;
                    newUsers.UserID  = _userManager.FindByNameAsync(user[i].UserName).Result.Id;

                    await _context.UserGroupMappers.AddAsync(newUsers);
                    await SaveChangesAsync();
                }
                else
                {
                    var result = await _userManager.CreateAsync(newUser);

                    if (result.Succeeded)
                    {
                        newUsers.UserID  = _userManager.FindByNameAsync(user[i].UserName).Result.Id;
                        newUsers.GroupID = groupId;

                        await _context.UserGroupMappers.AddAsync(newUsers);
                        await SaveChangesAsync();
                    }
                }

                if (friendList.Count != 0)
                {
                    List <Friend> userFriendList = await _context.Friends.Where(u => u.UserID.Equals(newUsers.UserID) || u.FriendID.Equals(newUsers.UserID)).ToListAsync();

                    if (!friendList.Any(f => f.FriendID.Equals(newUsers.UserID) || f.UserID.Equals(newUsers.UserID)))
                    {
                        newFriend.Add(new Friend
                        {
                            UserID   = currentUserId,
                            FriendID = newUsers.UserID
                        });

                        for (int j = i + 1; j < user.Count; j++)
                        {
                            if (allUsers.Contains(user[j].UserName.ToLower()))
                            {
                                if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id)))
                                {
                                    newFriend.Add(new Friend
                                    {
                                        UserID   = newUsers.UserID,
                                        FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                                    });
                                }
                            }
                            else
                            {
                                var newMember = new ApplicationUser
                                {
                                    FullName = user[j].FullName,
                                    UserName = user[j].UserName
                                };

                                var result = await _userManager.CreateAsync(newMember);

                                if (result.Succeeded)
                                {
                                    if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id)))
                                    {
                                        newFriend.Add(new Friend
                                        {
                                            UserID   = newUsers.UserID,
                                            FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                                        });
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        for (int j = i + 1; j < user.Count; j++)
                        {
                            if (allUsers.Contains(user[j].UserName.ToLower()))
                            {
                                if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id)))
                                {
                                    newFriend.Add(new Friend
                                    {
                                        UserID   = newUsers.UserID,
                                        FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                                    });
                                }
                            }
                            else
                            {
                                var newMember = new ApplicationUser
                                {
                                    FullName = user[j].FullName,
                                    UserName = user[j].UserName
                                };

                                var result = await _userManager.CreateAsync(newMember);

                                if (result.Succeeded)
                                {
                                    if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(user[j].UserName).Result.Id)))
                                    {
                                        newFriend.Add(new Friend
                                        {
                                            UserID   = newUsers.UserID,
                                            FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    newFriend.Add(new Friend
                    {
                        UserID   = currentUserId,
                        FriendID = newUsers.UserID
                    });

                    for (int j = i + 1; j < user.Count; j++)
                    {
                        if (allUsers.Contains(user[j].UserName.ToLower()))
                        {
                            newFriend.Add(new Friend
                            {
                                UserID   = newUsers.UserID,
                                FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                            });
                        }
                        else
                        {
                            var newMember = new ApplicationUser
                            {
                                FullName = user[j].FullName,
                                UserName = user[j].UserName
                            };

                            var result = await _userManager.CreateAsync(newMember);

                            if (result.Succeeded)
                            {
                                newFriend.Add(new Friend
                                {
                                    UserID   = newUsers.UserID,
                                    FriendID = _userManager.FindByNameAsync(user[j].UserName).Result.Id
                                });
                            }
                        }
                    }
                }

                foreach (var users in groupUsers.Where(g => !g.UserID.Equals(currentUserId)))
                {
                    List <Friend> userFriendList = await _context.Friends.Where(u => u.UserID.Equals(newUsers.UserID) || u.FriendID.Equals(newUsers.UserID)).ToListAsync();

                    if (!userFriendList.Any(f => f.FriendID.Equals(users.UserID) || f.UserID.Equals(users.UserID)))
                    {
                        newFriend.Add(new Friend
                        {
                            UserID   = newUsers.UserID,
                            FriendID = users.UserID
                        });
                    }
                }

                activityList.Add(new Activity
                {
                    UserID      = currentUserId,
                    Date        = DateTime.Now,
                    Description = $"You added {user[i].FullName} to {group}"
                });
            }
            await _context.Friends.AddRangeAsync(newFriend);

            await _context.Activities.AddRangeAsync(activityList);

            await SaveChangesAsync();
        }
        public async Task CreateGroupAsync(CreateGroupAC group, string userId)
        {
            List <Activity> activities = new List <Activity>();
            List <Friend>   friendList = await _context.Friends.Where(u => u.UserID.Equals(userId) || u.FriendID.Equals(userId)).ToListAsync();

            List <Friend> newFriend = new List <Friend>();

            var newGroup = new DomainModel.Models.Group
            {
                Name          = group.Name,
                Category      = group.Category,
                SimplifyDebts = group.SimplifyDebts,
                Note          = group.Note,
                DateCreated   = DateTime.Now,
                CreatedBy     = userId,
                IsDeleted     = false
            };

            activities.Add(new Activity
            {
                UserID      = newGroup.CreatedBy,
                Date        = DateTime.Now,
                Description = $"You created a group {newGroup.Name}"
            });

            await _context.Groups.AddAsync(newGroup);

            await SaveChangesAsync();

            var addedGroup = await _context.Groups.Where(g => g.ID == newGroup.ID).FirstOrDefaultAsync();

            var newUserGroup = new UserGroupMapper
            {
                GroupID = addedGroup.ID,
                UserID  = addedGroup.CreatedBy
            };

            await _context.UserGroupMappers.AddAsync(newUserGroup);

            await SaveChangesAsync();

            //List<Friend> allFriends = await _context.Friends.ToListAsync();

            for (int i = 0; i < group.UserGroupMapper.Count; i++)
            {
                var users = await _context.Users.Select(u => u.UserName).ToListAsync();

                UserGroupMapper newUserGroupMapper = new UserGroupMapper();

                var newUser = new ApplicationUser
                {
                    FullName = group.UserGroupMapper[i].FullName,
                    UserName = group.UserGroupMapper[i].UserName
                };

                if (users.Contains(group.UserGroupMapper[i].UserName.ToLower()))
                {
                    newUserGroupMapper.UserID  = _userManager.FindByNameAsync(group.UserGroupMapper[i].UserName).Result.Id;
                    newUserGroupMapper.GroupID = addedGroup.ID;

                    await _context.UserGroupMappers.AddAsync(newUserGroupMapper);
                    await SaveChangesAsync();
                }
                else
                {
                    var result = await _userManager.CreateAsync(newUser);

                    if (result.Succeeded)
                    {
                        newUserGroupMapper.UserID  = _userManager.FindByNameAsync(group.UserGroupMapper[i].UserName).Result.Id;
                        newUserGroupMapper.GroupID = addedGroup.ID;

                        await _context.UserGroupMappers.AddAsync(newUserGroupMapper);

                        await _context.SaveChangesAsync();
                    }
                }

                if (friendList.Count != 0)
                {
                    List <Friend> userFriendList = await _context.Friends.Where(u => u.UserID.Equals(newUserGroupMapper.UserID) || u.FriendID.Equals(newUserGroupMapper.UserID)).ToListAsync();

                    if (!friendList.Any(f => f.FriendID.Equals(newUserGroupMapper.UserID) || f.UserID.Equals(newUserGroupMapper.UserID)))
                    {
                        newFriend.Add(new Friend
                        {
                            UserID   = userId,
                            FriendID = newUserGroupMapper.UserID
                        });

                        for (int j = i + 1; j < group.UserGroupMapper.Count; j++)
                        {
                            if (users.Contains(group.UserGroupMapper[j].UserName.ToLower()))
                            {
                                if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                                {
                                    newFriend.Add(new Friend
                                    {
                                        UserID   = newUserGroupMapper.UserID,
                                        FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                    });
                                }
                            }
                            else
                            {
                                var newMember = new ApplicationUser
                                {
                                    FullName = group.UserGroupMapper[j].FullName,
                                    UserName = group.UserGroupMapper[j].UserName
                                };

                                var result = await _userManager.CreateAsync(newMember);

                                if (result.Succeeded)
                                {
                                    if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                                    {
                                        newFriend.Add(new Friend
                                        {
                                            UserID   = newUserGroupMapper.UserID,
                                            FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                        });
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        for (int j = i + 1; j < group.UserGroupMapper.Count; j++)
                        {
                            if (users.Contains(group.UserGroupMapper[j].UserName.ToLower()))
                            {
                                if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                                {
                                    newFriend.Add(new Friend
                                    {
                                        UserID   = newUserGroupMapper.UserID,
                                        FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                    });
                                }
                            }
                            else
                            {
                                var newMember = new ApplicationUser
                                {
                                    FullName = group.UserGroupMapper[j].FullName,
                                    UserName = group.UserGroupMapper[j].UserName
                                };

                                var result = await _userManager.CreateAsync(newMember);

                                if (result.Succeeded)
                                {
                                    if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                                    {
                                        newFriend.Add(new Friend
                                        {
                                            UserID   = newUserGroupMapper.UserID,
                                            FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    List <Friend> userFriendList = await _context.Friends.Where(u => u.UserID.Equals(newUserGroupMapper.UserID) || u.FriendID.Equals(newUserGroupMapper.UserID)).ToListAsync();

                    newFriend.Add(new Friend
                    {
                        UserID   = userId,
                        FriendID = newUserGroupMapper.UserID
                    });

                    for (int j = i + 1; j < group.UserGroupMapper.Count; j++)
                    {
                        if (users.Contains(group.UserGroupMapper[j].UserName.ToLower()))
                        {
                            if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                            {
                                newFriend.Add(new Friend
                                {
                                    UserID   = newUserGroupMapper.UserID,
                                    FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                });
                            }
                        }
                        else
                        {
                            var newMember = new ApplicationUser
                            {
                                FullName = group.UserGroupMapper[j].FullName,
                                UserName = group.UserGroupMapper[j].UserName
                            };

                            var result = await _userManager.CreateAsync(newMember);

                            if (result.Succeeded)
                            {
                                if (!userFriendList.Any(f => f.FriendID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id) || f.UserID.Equals(_userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id)))
                                {
                                    newFriend.Add(new Friend
                                    {
                                        UserID   = newUserGroupMapper.UserID,
                                        FriendID = _userManager.FindByNameAsync(group.UserGroupMapper[j].UserName).Result.Id
                                    });
                                }
                            }
                        }
                    }
                }

                activities.Add(new Activity
                {
                    UserID      = newGroup.CreatedBy,
                    Date        = DateTime.Now,
                    Description = $"You added {group.UserGroupMapper[i].FullName} to {group.Name}"
                });
            }

            await _context.Friends.AddRangeAsync(newFriend);

            await _context.Activities.AddRangeAsync(activities);

            await SaveChangesAsync();
        }