/// <summary>
 /// thêm matchType
 /// </summary>
 private void GroupUser_Add()
 {
     try
     {
         Group_User creGroup_User = new Group_User();
         creGroup_User.Owner = Window.GetWindow(this);
         creGroup_User.ShowDialog();
         if (creGroup_User.c_createOk == 1)
         {
             LoadData();
             for (int i = 0; i < arrAllGroupUser.Count; i++)
             {
                 GroupUserInfo ui = (GroupUserInfo)arrAllGroupUser[i];
                 if (ui.Id == c_IdInsert)
                 {
                     rowselect  = i;
                     c_IdInsert = 0;
                     break;
                 }
             }
             DataGridHelper.NVSFocus(dgrGroupUser, rowselect, 1);
             creGroup_User.c_createOk = 0;
         }
     }
     catch (Exception ex)
     {
         CommonData.log.Error(ex.ToString());
     }
 }
Beispiel #2
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,GroupId,UserId")] Group_User group_User)
        {
            if (id != group_User.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(group_User);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!Group_UserExists(group_User.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["GroupId"] = new SelectList(_context.Group, "GroupId", "GroupName", group_User.GroupId);
            ViewData["UserId"]  = new SelectList(_context.Users, "Id", "UserName", group_User.UserId);
            return(View(group_User));
        }
        //Functions
        public Result <GroupServiceModel> Add(GroupServiceModel group, int userId)
        {
            var result = new Result <GroupServiceModel>();

            //initialize transaction
            var transaction = _unitOfWork.BeginTransaction();

            try
            {
                //No mapping. Because system properties shouldn't be null.
                var newGroup = new Group()
                {
                    Name      = group.Name,
                    IsActive  = true,
                    MediaId   = group.MediaId,
                    CreatedOn = Application.CurrentDate,
                    CreatedBy = userId,
                    UpdatedOn = Application.CurrentDate,
                    UpdatedBy = userId
                };
                _unitOfWork.GroupRepository.Add(newGroup);
                _unitOfWork.Save();

                var newGroupUser = new Group_User()
                {
                    GroupId  = newGroup.Id,
                    UserId   = userId,
                    IsActive = true
                };
                _unitOfWork.GroupUserRepository.Add(newGroupUser);
                _unitOfWork.Save();

                //commit transaction
                transaction.commit();

                //return mapped new group
                var mappedNewGroup = _mapper.Map <GroupServiceModel>(newGroup);

                result.IsSuccess = true;
                result.Data      = mappedNewGroup;
                return(result);
            }
            catch (Exception ex)
            {
                //rollback transaction
                transaction.Rollback();
                _logger.LogError(ex.InnerException.Message);
                result.IsSuccess    = false;
                result.ErrorMessage = ErrorMessage.Add;
                return(result);
            }
        }
 /// <summary>
 /// Created By  : sangeee
 /// Created On  :  07 Aug 2018
 /// Description : Delete an User from a Group
 /// </summary>
 /// <param name="group_User"></param>
 /// <returns></returns>
 public bool DeleteUserFromGroup(Group_User group_User)
 {
     try
     {
         Group_User _resourceExistDb = _unitOfWork.Group_UserRepository.GetSingle(x => x.GroupId == group_User.GroupId && x.UserId == group_User.UserId);
         if (_resourceExistDb == null)
         {
             return(false);
         }
         _unitOfWork.Group_UserRepository.DeleteWhere(x => x.UserId == group_User.UserId && x.GroupId == group_User.GroupId);
         _unitOfWork.Commit();
         return(true);
     }
     catch (Exception ex) { return(false); }
 }
Beispiel #5
0
        public void SaveGroupUser([FromBody] List <Object> listUserGroup, string CodeGroup)
        {
            int    a    = listUserGroup.Count;
            string list = ";";

            #region add user group
            for (int i = 0; i < a; i++)
            {
                UserProfile result = JsonConvert.DeserializeObject <UserProfile>(listUserGroup[i].ToString());
                var         dt     = db.Group_User.Where(t => t.UserName == result.UserName && t.CodeGroup == CodeGroup).FirstOrDefault();
                if (dt == null)
                {
                    dt             = new Group_User();
                    dt.FCode       = System.Guid.NewGuid().ToString();
                    dt.FCreateTime = System.DateTime.Now;
                    dt.FUpdateTime = System.DateTime.Now;
                    dt.FUserCreate = RequestContext.Principal.Identity.Name;
                    dt.CodeGroup   = CodeGroup;
                    dt.UserName    = result.UserName;
                    // dt.FBranchCode = result.FBranchCode;
                    dt.FInUse = true;
                    db.Group_User.Add(dt);
                    db.SaveChanges();
                }
                else
                {
                    dt.FInUse = true;
                    db.SaveChanges();
                }
                list += result.UserName + ";";
            }
            #endregion

            #region xóa những user tồn tại trong group nhưng không có trong list add group ở trên
            var User = db.Group_User.Where(t => t.CodeGroup == CodeGroup && t.FInUse == true).ToList();
            //if (list != ";")
            //{
            foreach (var it in User)
            {
                if (!list.Contains(";" + it.UserName + ";"))
                {
                    it.FInUse = false;
                    db.SaveChanges();
                }
            }
            //}
            #endregion
        }
Beispiel #6
0
        public void CreateGroup_User(string[] listUser, string groupName)
        {
            if (listUser != null)
            {
                string myUserId         = Context.User.Identity.Name; // tạo group phải có mình trong đó
                string groupnameDefault = "";
                string NameFirstsend    = "";

                foreach (var item in listUser)
                {
                    groupnameDefault += item + "|";
                    NameFirstsend    += item + "|";
                }

                groupnameDefault += myUserId;

                Group group = new Group();
                group.GroupName = string.IsNullOrWhiteSpace(groupName) ? groupnameDefault : groupName;
                group.GroupType = "G";
                db.Groups.Add(group);

                foreach (var item in listUser)
                {
                    Group_User userGroup = new Group_User();
                    userGroup.GroupId     = group.GroupId;
                    userGroup.UserOfGroup = db.UserLogins.FirstOrDefault(ul => ul.UserNameCopy == item).Id;
                    db.Group_User.Add(userGroup);
                }

                Group_User myGroup = new Group_User();
                myGroup.GroupId     = group.GroupId;
                myGroup.UserOfGroup = db.UserLogins.FirstOrDefault(ul => ul.UserNameCopy == myUserId).Id;
                db.Group_User.Add(myGroup);

                try
                {
                    db.SaveChanges();
                }
                catch (Exception)
                {
                    throw;
                }

                SendPrivateMessage(group.GroupId.ToString(), myUserId + " Đã thêm " + NameFirstsend + " vào nhóm ");
            }
        }
Beispiel #7
0
        public async Task <IActionResult> Create([Bind("GroupId,UserId")] Group_User group_User)
        {
            var GroupId = group_User.GroupId;
            var check   = from gu in _context.Group_User
                          where gu.GroupId == group_User.GroupId && gu.UserId == group_User.UserId
                          select gu;

            if (ModelState.IsValid && check.Count() == 0)
            {
                _context.Add(group_User);
                await _context.SaveChangesAsync();

                return(RedirectToAction("User", "Groups", new { id = GroupId }));
            }

            return(RedirectToAction("User", "Groups", new { id = GroupId }));
        }
Beispiel #8
0
        public void SaveGroupByUser(string CodeGroup, string user)
        {
            var check = db.Group_User.Where(t => t.UserName == user).ToList();

            if (check.Any())
            {
                db.Group_User.RemoveRange(check);
                db.SaveChanges();
            }
            var model     = JsonConvert.DeserializeObject <List <string> >(CodeGroup);
            var ListGroup = ";";

            foreach (var item in model)
            {
                if (item != "")
                {
                    var dt = db.Group_User.Where(t => t.UserName == user && t.CodeGroup == item).FirstOrDefault();
                    if (dt != null)
                    {
                        dt.FInUse = true;
                        db.SaveChanges();
                    }
                    else
                    {
                        dt           = new Group_User();
                        dt.FCode     = Guid.NewGuid().ToString();
                        dt.UserName  = user;
                        dt.CodeGroup = item;
                        db.Group_User.Add(dt);
                        db.SaveChanges();
                    }
                    ListGroup += item + ";";
                }
            }
            var DelGroup = db.Group_User.Where(t => t.UserName == user && t.CodeGroup != Commons.Constants.SUPPERADMIN).ToList();

            foreach (var i in DelGroup)
            {
                if (!ListGroup.Contains(i.CodeGroup))
                {
                    i.FInUse = false;
                    db.SaveChanges();
                }
            }
        }
 /// <summary>
 /// CreatedBy  : sangeee
 /// CreatedOn  :  07 Aug 2018
 /// Description : Add new User to Group
 /// </summary>
 /// <param name="group_User"></param>
 /// <returns></returns>
 public bool AddUserToGroup(Group_User group_User)
 {
     try
     {
         Group_User _resourceExistDb = _unitOfWork.Group_UserRepository.GetSingle(x => x.GroupId == group_User.GroupId && x.UserId == group_User.UserId);
         if (_resourceExistDb == null)
         {
             _unitOfWork.Group_UserRepository.Add(group_User);
         }
         else
         {
             _unitOfWork.Group_UserRepository.Update(group_User);
         }
         _unitOfWork.Commit();
         return(true);
     }
     catch (Exception ex) { return(false); }
 }
Beispiel #10
0
 public IActionResult DeleteUserFromGroup([FromBody] Group_User group_User)
 {
     try
     {
         if (!ModelState.IsValid)
         {
             return(BadRequest(ModelState));
         }
         bool status = GroupModel.DeleteUserFromGroup(group_User);
         if (status)
         {
             return(Ok());
         }
         else
         {
             return(new NotFoundResult());
         }
     }
     catch (Exception ex) { return(BadRequest(ex)); }
 }
        private string getAllSalesMenIDs()
        {
            string salesMenIDs = "";

            try
            {
                Group gp = new Group();
                gp.Where.Active.Value = 1;
                gp.Where.Name.Value   = "SalesMen";
                gp.Query.Load();
                if (gp.RowCount > 0)
                {
                    Group_User gpUser = new Group_User();
                    gpUser.Where.Active.Value  = 1;
                    gpUser.Where.GroupID.Value = gp.ID;
                    if (gpUser.Query.Load())
                    {
                        if (gpUser.DefaultView != null && gpUser.DefaultView.Count > 0)
                        {
                            do
                            {
                                if (salesMenIDs == "")
                                {
                                    salesMenIDs = "'" + gpUser.UserID + "'";
                                }
                                else
                                {
                                    salesMenIDs += ",'" + gpUser.UserID + "'";
                                }
                            } while (gpUser.MoveNext());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //Logger.LogException(ex);
            }
            return(salesMenIDs);
        }
Beispiel #12
0
        private string getUserGroup()
        {
            string     groupName = "";
            Group_User gpUser    = new Group_User();

            gpUser.Where.UserID.Value = UserID;
            gpUser.Where.Active.Value = true;
            gpUser.Query.AddOrderBy(Group_User.ColumnNames.GroupID, WhereParameter.Dir.ASC);
            gpUser.Query.Load();
            if (gpUser.RowCount > 0)
            {
                gpUser.Rewind();
                Group gp = new Group();
                if (gp.LoadByPrimaryKey(gpUser.GroupID))
                {
                    if (gp.Active)
                    {
                        groupName = gp.Name.Trim();
                    }
                }
            }
            return(groupName);
        }
Beispiel #13
0
        private string getMyTaskIDs()
        {
            string taskIDs = "";
            Dictionary <long, bool> taskIDDict = new Dictionary <long, bool>();
            TaskPermission          taskPerm   = new TaskPermission();

            taskPerm.Where.UserGroupID.Value = UserID;
            taskPerm.Where.IsGroup.Value     = false;

            if (taskPerm.Query.Load())
            {
                if (taskPerm.DefaultView != null && taskPerm.DefaultView.Count > 0)
                {
                    do
                    {
                        if (taskIDs == "")
                        {
                            if (!taskIDDict.ContainsKey(taskPerm.TaskID))
                            {
                                taskIDDict.Add(taskPerm.TaskID, true);
                                taskIDs = "'" + taskPerm.TaskID + "'";
                            }
                        }
                        else
                        {
                            if (!taskIDDict.ContainsKey(taskPerm.TaskID))
                            {
                                taskIDDict.Add(taskPerm.TaskID, true);
                                taskIDs += ",'" + taskPerm.TaskID + "'";
                            }
                        }
                    } while (taskPerm.MoveNext());
                }
            }
            string     gpIDs  = "";
            Group_User gpUser = new Group_User();

            gpUser.Where.Active.Value = true;
            gpUser.Where.UserID.Value = UserID;
            if (gpUser.Query.Load())
            {
                if (gpUser.DefaultView != null && gpUser.DefaultView.Count > 0)
                {
                    do
                    {
                        if (gpIDs == "")
                        {
                            gpIDs = "'" + gpUser.GroupID + "'";
                        }
                        else
                        {
                            gpIDs += ",'" + gpUser.GroupID + "'";
                        }
                    } while (gpUser.MoveNext());
                }
            }
            if (gpIDs != "")
            {
                TaskPermission gpTasks = new TaskPermission();
                gpTasks.Where.UserGroupID.Value    = gpIDs;
                gpTasks.Where.UserGroupID.Operator = WhereParameter.Operand.In;
                gpTasks.Where.IsGroup.Value        = true;


                if (gpTasks.Query.Load())
                {
                    if (gpTasks.DefaultView != null && gpTasks.DefaultView.Count > 0)
                    {
                        do
                        {
                            if (taskIDs == "")
                            {
                                if (!taskIDDict.ContainsKey(gpTasks.TaskID))
                                {
                                    taskIDDict.Add(gpTasks.TaskID, true);
                                    taskIDs = "'" + gpTasks.TaskID + "'";
                                }
                            }
                            else
                            {
                                if (!taskIDDict.ContainsKey(gpTasks.TaskID))
                                {
                                    taskIDDict.Add(gpTasks.TaskID, true);
                                    taskIDs += ",'" + gpTasks.TaskID + "'";
                                }
                            }
                        } while (gpTasks.MoveNext());
                    }
                }
            }
            return(taskIDs);
        }