コード例 #1
0
        public ActionResult ChangeEmployeeRoles(string userID)
        {
            ViewBag.Username     = UserManager.FindById(userID).UserName;
            ViewBag.ErrorMessage = "";

            var           employeeRoles  = UserManager.GetRoles(userID);
            var           allRoles       = RoleManager.Roles.Where(r => r.Name != "SuperUser").ToList();
            List <string> availableRoles = new List <string>();
            List <string> allRolesText   = new List <string>();

            foreach (var i in allRoles)
            {
                availableRoles.Add(i.Name); allRolesText.Add(i.Name);
            }
            // filter for available roles
            foreach (var er in employeeRoles)
            {
                foreach (var ar in allRolesText)
                {
                    if (er.Equals(ar))
                    {
                        availableRoles.Remove(ar);
                    }
                }
            }
            ViewBag.EmployeeRoles  = (List <string>)employeeRoles;
            ViewBag.AvailableRoles = availableRoles;
            var roles = new EmployeeRoleViewModel()
            {
                UserID = userID
            };

            return(View(roles));
        }
コード例 #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="employeeId"></param>
        /// <returns></returns>
        public async Task <IResult> GetEmployeeById(int employeeId)
        {
            var result = new Result
            {
                Operation  = Operation.Read,
                Status     = Status.Success,
                StatusCode = HttpStatusCode.OK
            };

            try
            {
                if (employeeId > 0)
                {
                    var employeeVm    = new EmployeeViewModel();
                    var employeeModel = await _employeeRepository.GetEmployeeById(employeeId);

                    if (employeeModel != null)
                    {
                        employeeVm.MapFromModel(employeeModel);
                        var roles = new List <EmployeeRoleViewModel>();
                        roles = employeeModel.EmployeeRoles.Select(t =>
                        {
                            var role        = new EmployeeRoleViewModel();
                            role.Id         = t.Id;
                            role.RoleId     = t.RoleId;
                            role.RoleName   = t.Role.Name;
                            role.EmployeeId = t.EmployeeId;
                            return(role);
                        }).ToList();
                        employeeVm.Roles = roles;
                        result.Body      = employeeVm;
                    }
                    else
                    {
                        result.Body       = null;
                        result.Message    = "Employee Id does not exists";
                        result.Status     = Status.Fail;
                        result.StatusCode = HttpStatusCode.NotFound;
                    }
                    return(result);
                }
                result.Status     = Status.Fail;
                result.StatusCode = HttpStatusCode.BadRequest;
                return(result);
            }
            catch (Exception e)
            {
                result.Message    = e.Message;
                result.Status     = Status.Error;
                result.StatusCode = HttpStatusCode.InternalServerError;
                return(result);
            }
        }
 public IActionResult UpdateEmployee(EmployeeRoleViewModel model)
 {
     try
     {
         return(Ok(ep.UpdateEmployee(model)));
     }
     catch (Exception ex)
     {
         Exceptions(ex);
         return(StatusCode(500));
     }
 }
 public int UpdateEmployee(EmployeeRoleViewModel model)
 {
     try
     {
         return(employee.UpdateEmployee(model));
     }
     catch (Exception ex)
     {
         StaticHelper.LogException(path: up.GetLogFilePath(), errorMessage: ex.Message, methodName: $"Class Name: {nameof(EmployeePresenter)} - Method name:  {nameof(UpdateEmployee)}", stackTrace: ex.StackTrace);
         return(0);
     }
 }
コード例 #5
0
        public ActionResult ChangeEmployeeRoles(EmployeeRoleViewModel model)
        {
            var result = UserManager.AddToRole(model.UserID, model.Role);

            if (result.Succeeded)
            {
                return(RedirectToAction("ManageEmployee", new { userID = model.UserID }));
            }
            else
            {
                ViewBag.ErrorMessage = "Unable to assign role. Please try again.";
                return(View(model));
            }
        }
コード例 #6
0
        /// <summary>
        /// Returns employees
        /// </summary>
        /// <returns></returns>
        public IResult GetEmployeeList(SearchSortModel search)
        {
            var employeeViewModels = new List <EmployeeViewModel>();
            var result             = new Result
            {
                Operation  = Operation.Read,
                Status     = Status.Success,
                StatusCode = HttpStatusCode.OK
            };

            try
            {
                var employees = _employeeRepository.GetAllEmployees(search);
                if (employees.Any())
                {
                    employeeViewModels = employees.Select(t =>
                    {
                        var employeeViewModel = new EmployeeViewModel();
                        employeeViewModel.MapFromModel(t);
                        var roles = new List <EmployeeRoleViewModel>();
                        roles     = t.EmployeeRoles.Select(r =>
                        {
                            var role        = new EmployeeRoleViewModel();
                            role.Id         = r.Id;
                            role.RoleId     = r.RoleId;
                            role.RoleName   = r.Role.Name;
                            role.EmployeeId = r.EmployeeId;
                            return(role);
                        }).ToList();

                        employeeViewModel.Roles = roles;
                        return(employeeViewModel);
                    }).ToList();
                }
                else
                {
                    result.Message = "No records found";
                }
                search.SearchResult = employeeViewModels;
                result.Body         = search;
            }
            catch (Exception ex)
            {
                result.Status     = Status.Error;
                result.Message    = ex.Message;
                result.StatusCode = HttpStatusCode.InternalServerError;
            }
            return(result);
        }
        public int UpdateEmployee(EmployeeRoleViewModel model)
        {
            try
            {
                var recordToUpdateInDb = dbContext.TblEmployee.Where(x => x.Id == model.EmployeeId).FirstOrDefault();
                if (recordToUpdateInDb != null)
                {
                    var duplicateNameRecord = dbContext.TblEmployee.Where(x => x.Id != model.EmployeeId &&
                                                                          x.FullName == model.FullName &&
                                                                          x.UserName == model.Username &&
                                                                          x.PhoneNo == model.PhoneNo).FirstOrDefault();

                    if (duplicateNameRecord != null)
                    {
                        return(0);
                    }
                    else
                    {
                        recordToUpdateInDb.FullName = model.FullName;
                        recordToUpdateInDb.UserName = model.Username;
                        recordToUpdateInDb.PhoneNo  = model.PhoneNo;
                        recordToUpdateInDb.Password = model.Password;
                        recordToUpdateInDb.RoleId   = model.RoleId;
                        return(dbContext.SaveChanges());
                    }
                }
                else
                {
                    return(0);
                }
            }
            catch (Exception ex)
            {
                StaticHelper.LogException(path: up.GetLogFilePath(), errorMessage: ex.Message, methodName: $"Repository name: {nameof(EmployeeRepository)} - Method name:  {nameof(UpdateEmployee)}", stackTrace: ex.StackTrace);
                return(0);
            }
        }
コード例 #8
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="loginModel"></param>
        /// <returns></returns>
        public async Task <IResult> GetEmployee(UserLoginViewModel loginModel)
        {
            var result = new Result
            {
                Operation  = Operation.Read,
                Status     = Status.Success,
                StatusCode = HttpStatusCode.OK
            };

            try
            {
                if (loginModel != null)
                {
                    var employeeModel = await _employeeRepository.GetEmployeeByEmail(loginModel.Email);

                    if (employeeModel == null)
                    {
                        result.Body       = null;
                        result.Message    = "Account with " + loginModel.Email + " does not exists.";
                        result.Status     = Status.Fail;
                        result.StatusCode = HttpStatusCode.NotFound;
                        return(result);
                    }
                    else
                    {
                        if (!BC.Verify(loginModel.Password, employeeModel.Password))
                        {
                            result.Body       = null;
                            result.Message    = "Password is incorrect";
                            result.Status     = Status.Fail;
                            result.StatusCode = HttpStatusCode.Forbidden;
                            return(result);
                        }
                        // check if employee is confirmed or not
                        if (employeeModel.Status == EntityStatus.Accept)
                        {
                            var roles = new List <EmployeeRoleViewModel>();
                            roles = employeeModel.EmployeeRoles.Select(t =>
                            {
                                var role        = new EmployeeRoleViewModel();
                                role.Id         = t.Id;
                                role.RoleId     = t.RoleId;
                                role.RoleName   = t.Role.Name;
                                role.EmployeeId = t.EmployeeId;
                                return(role);
                            }).ToList();

                            UserViewModel userView = new UserViewModel()
                            {
                                Email        = employeeModel.Email,
                                EmployeeCode = employeeModel.EmployeeCode,
                                Name         = employeeModel.Name,
                                UserId       = employeeModel.Id,
                                CurrentResidentialAddress   = employeeModel.CurrentResidentialAddress,
                                PermanentResidentialAddress = employeeModel.PermanentResidentialAddress,
                                Token = GenerateToken(employeeModel.Name, employeeModel.Email),
                                Roles = roles
                            };
                            result.Body = userView;
                        }
                        else if (employeeModel.Status == EntityStatus.Deny)
                        {
                            result.Body       = null;
                            result.Message    = "Your account has declined by the HR";
                            result.Status     = Status.Fail;
                            result.StatusCode = HttpStatusCode.Forbidden;
                        }
                        else
                        {
                            result.Body       = null;
                            result.Message    = "Your account has not confirmed yet by the HR";
                            result.Status     = Status.Fail;
                            result.StatusCode = HttpStatusCode.Unauthorized;
                        }
                    }
                    return(result);
                }
                else
                {
                    result.Status     = Status.Fail;
                    result.StatusCode = HttpStatusCode.BadRequest;
                    return(result);
                }
            }
            catch (Exception e)
            {
                result.Message = e.Message;
                result.Status  = Status.Error;
                return(result);
            }
        }
コード例 #9
0
 public async Task <ResponseViewModel <EmployeeRoleViewModel> > DeleteEmployeeRole([FromBody] EmployeeRoleViewModel employeeRoleView)
 {
     return(await _adminService.DeleteEmployeeRole(employeeRoleView));
 }