Example #1
0
        public ActionResult CreateAccount(UserVM model)
        {
            //Проверка на валидность
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            //Проверка соответствия пароля
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Неверный пароль!");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                //Проверка имени на уникальность
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", $"Логин {model.Username} занят");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                //Создание экземпляра класса UserDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName   = model.FirstName,
                    LastName    = model.LastName,
                    EmailAdress = model.EmailAdress,
                    Username    = model.Username,
                    Password    = model.Password
                };

                //Добавление всех даанных в модель
                db.Users.Add(userDTO);

                //Сохранение данных
                db.SaveChanges();

                //Добавление роли пользователя
                int id = userDTO.Id;

                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }

            //Запись сообщения в TempData
            TempData["M"] = "Теперь вы зарегистрированы и можете войти в аккаунт";

            //Переадресация пользователя
            return(RedirectToAction("Login"));
        }
Example #2
0
        public ActionResult CreateAccount(UserVM model)
        {
            // Проверяем модель на валидность.
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // Проверяем соответствие пароля.
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Password do not equals!");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                // Проверяем имя на уникальность.
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", $"Username {model.Username} is taken.");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }
                // Создаём экземляр класса контекста данных UserDTO.
                UserDTO userDTO = new UserDTO()
                {
                    FirstName   = model.FirstName,
                    LastName    = model.LastName,
                    EmailAdress = model.EmailAdress,
                    Username    = model.Username,
                    Password    = model.Password
                };

                // Добавляем данные в экземпляр класса.
                db.Users.Add(userDTO);

                // Сохраняем данные.
                db.SaveChanges();

                // Добавляем роль пользователю.
                int id = userDTO.Id;

                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }

            // Записываем сообщение в TempData.
            TempData["SM"] = "Tou are now registered and can login.";

            // Переадресовываем пользователя.

            return(RedirectToAction("Login"));
        }
    private void Save()
    {
        bool bActionCompleted = false;

        if (!base.ValidateIfCommandAllowed(Request.Url.AbsoluteUri, ENums.PageCommand.Add))
        {
            return;
        }

        if (!ValidateValues())
        {
            return;
        }

        UserRoleDTO oUserRoleData = new UserRoleDTO();

        oUserRoleData.UserRoleName = Convert.ToString(txtUserRoleName.Text);
        UserRoleMaster oUserRoleMaster = new UserRoleMaster();

        bActionCompleted = oUserRoleMaster.Insert(oUserRoleData);
        if (bActionCompleted == true)
        {
            base.DisplayAlert("The record has been inserted successfully");
            txtUserRoleName.Text = string.Empty;
        }
        else
        {
            lblStatus.Text = "Error Occured while insertion: Please refer to the error log.";
        }
    }
Example #4
0
        public ActionResult DoAddUserRole(AddUserRoleViewModel model)
        {
            JsonResult result = new JsonResult();

            if ((model != null) && ModelState.IsValid)
            {
                try
                {
                    UserRoleDTO userRole = new UserRoleDTO
                    {
                        UserId = model.UserId,
                        RoleId = model.SelectedRole
                    };
                    _bl.UserRoles.Create(userRole);
                    result.Data = new { Code = 0, Message = "OK" };
                }
                catch (NoteCustomException e)
                {
                    result.Data = new { Code = -1, e.Message };
                }
                catch (Exception e)
                {
                    result.Data = new { Code = -2, Message = $"Системная ошибка: {e.Message}" };
                }
            }
            else
            {
                result.Data = new { Code = -3, Message = "Неверные параметы" };
            }
            return(result);
        }
        public void Setup()
        {
            // Mock
            _configuration = new Mock <IConfiguration>(MockBehavior.Loose);
            _userRoleRepo  = new Mock <IUserRoleRepo>(MockBehavior.Loose);
            _logger        = new Mock <ILogger <UserRoleController> >(MockBehavior.Loose);

            // Mapper
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new AutoMapperConfig());
            });

            _mapper = new Mapper(config);

            // Config
            Filler <UserRole>    pFiller    = new Filler <UserRole>();
            Filler <UserRoleDTO> pFillerDTO = new Filler <UserRoleDTO>();

            userRole    = pFiller.Create();
            userRoleDTO = pFillerDTO.Create();

            // Service under test
            _userRoleController = new UserRoleController(_configuration.Object, _mapper, _userRoleRepo.Object, _logger.Object);
        }
Example #6
0
        public ActionResult CreateAccount(UserVM model)
        {
            // Check model state
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // Check if passwords match
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Passwords do not match.");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                // Make sure username is unique
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", "Username " + model.Username + " is taken.");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                // Create userDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    Username     = model.Username,
                    Password     = model.Password
                };

                // Add the DTO
                db.Users.Add(userDTO);

                // Save
                db.SaveChanges();

                // Add to UserRolesDTO
                int id = userDTO.Id;

                UserRoleDTO userRolesDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRolesDTO);
                db.SaveChanges();
            }

            // Create a TempData message
            TempData["SM"] = "You are now registered and can login.";

            // Redirect
            return(Redirect("~/account/login"));
        }
        public IActionResult PostRoleIdToUserId([FromBody] UserRoleInputModel userRole)
        {
            UserMapper      mapper = new UserMapper();
            AdminDataAccess adm    = new AdminDataAccess();
            var             user   = adm.GetUserByID(userRole.UserID);

            if (user == null)
            {
                return(BadRequest("Пользователя не существует"));
            }
            var role = adm.GetRoleByRoleId(userRole.RoleID);

            if (role == null)
            {
                return(BadRequest("Такой роли не существует"));
            }
            List <UserRoleDTO> roles = adm.GetRolesByUserId(userRole.UserID);
            UserRoleDTO        rl    = mapper.ConvertUserRoleInputModelToUserRoleDTO(userRole);

            if (roles.Contains(rl))
            {
                return(Ok("Данная роль для пользователя уже создана"));
            }
            bool result = adm.UserRoleCreate(mapper.ConvertUserRoleInputModelToUserRoleDTO(userRole));

            if (result)
            {
                return(Ok("Роль пользователя создана"));
            }
            else
            {
                return(BadRequest("Ошибка запроса"));
            }
        }
Example #8
0
        public ActionResult ChangeUserRole(int id)
        {
            using (Db db = new Db())
            {
                var userrole = db.UserRoles.Where(x => x.UserId == id).FirstOrDefault();
                var roleid   = userrole.RoleId;
                db.UserRoles.Remove(userrole);
                var roleidtemp = 0;
                if (roleid == 1)
                {
                    roleidtemp = 2;
                }
                else
                {
                    roleidtemp = 1;
                }

                var newuserrole = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = roleidtemp
                };
                db.UserRoles.Add(newuserrole);
                db.SaveChanges();
            }
            return(RedirectToAction("Users"));
        }
Example #9
0
 public bool AddUserAndAssingRole(UserRoleDTO userDTO)
 {
     using (var dbContextTransaction = LogicXDBContext.Database.BeginTransaction())
     {
         var flag = false;
         try
         {
             Users user = new Users();
             user.user_name            = userDTO.user_name;
             user.user_phone           = userDTO.user_phone;
             user.user_email           = userDTO.user_email;
             user.user_date_of_joining = userDTO.user_date_of_joining;
             user.password             = userDTO.password;
             user.comany_id            = userDTO.company_id;
             LogicXDBContext.Users.Add(user);
             LogicXDBContext.SaveChanges();
             User_Roles userRole = new User_Roles();
             userRole.role_id          = userDTO.role_id;
             userRole.user_id          = user.user_id;
             userRole.role_assign_date = DateTime.Now;
             LogicXDBContext.User_Roles.Add(userRole);
             LogicXDBContext.SaveChanges();
             dbContextTransaction.Commit();
             flag = true;
         }
         catch (Exception)
         {
             dbContextTransaction.Rollback();
             flag = false;
         }
         return(flag);
     }
 }
Example #10
0
        public bool Delete(UserRoleDTO oUserRoleData)
        {
            string          sProcName;
            DatabaseManager oDB;

            try
            {
                oDB = new DatabaseManager();

                sProcName = "up_Del_UserRoleMaster";
                oDB.DbCmd = oDB.GetStoredProcCommand(sProcName);
                oDB.DbDatabase.AddInParameter(oDB.DbCmd, "@UserRoleId", DbType.Int32, oUserRoleData.UserRoleId);
                oDB.ExecuteNonQuery(oDB.DbCmd);
            }
            catch (Exception exp)
            {
                oDB           = null;
                oUserRoleData = null;
                GF.LogError("clsUserRoleMaster.Delete", exp.Message);
                return(false);
            }
            finally
            {
                oDB           = null;
                oUserRoleData = null;
            }
            return(true);
        }
Example #11
0
        private UserRoleDTO[] GetData(int UserRoleId)
        {
            UserRoleDTO[] oUserRoleData;
            oUserRoleData = null;
            DataSet ds;
            string  query = "select UserRoleId, UserRoleName from tblUserRoleMaster where 1=1";

            if (UserRoleId != 0)
            {
                query += " and UserRoleId=" + UserRoleId;
                query += " order by UserRoleName";
            }
            ds = GetDataFromDB(query);
            if (ds != null && ds.Tables[0].Rows.Count > 0)
            {
                oUserRoleData = new UserRoleDTO[ds.Tables[0].Rows.Count];
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    oUserRoleData[i]              = new UserRoleDTO();
                    oUserRoleData[i].UserRoleId   = Convert.ToInt32(ds.Tables[0].Rows[i][0]);
                    oUserRoleData[i].UserRoleName = Convert.ToString(ds.Tables[0].Rows[i][1]);
                }
            }
            return(oUserRoleData);
        }
 public ActionResult Create(UserRoleDTO userRole)
 {
     MethodBase method = MethodBase.GetCurrentMethod();
     try
     {
         UserRole newUserRole = Mapper.Map<UserRole>(userRole);
         newUserRole.IsValid = true;
         newUserRole.Id = 0;
         var response = UserRoleRepo.Create(newUserRole);
         if (response > 0)
         {
             CreateLog(Enums.Success, GetMethodCode(method), LogLevel.Information);
             return Ok(response);
         }
         else
         {
             CreateLog(Enums.BadRequest, GetMethodCode(method), LogLevel.Warning);
             return BadRequest(response);
         }
     }
     catch (Exception ex)
     {
         return HandleError(ex.Message, GetMethodCode(method));
     }
 }
Example #13
0
 public void Update(UserRoleDTO userRole)
 {
     if (userRole != null)
     {
         try
         {
             IMapper  mapper         = new MapperConfiguration(c => c.CreateMap <UserRoleDTO, UserRole>()).CreateMapper();
             UserRole userRoleEntity = mapper.Map <UserRoleDTO, UserRole>(userRole);
             if (userRoleEntity != null)
             {
                 _db.UserRoles.Save(userRoleEntity);
             }
             else
             {
                 throw new NoteDataException("Ошибка преобразования объекта");
             }
         }
         catch (NoteCustomException)
         {
             throw;
         }
         catch (Exception e)
         {
             throw new NoteCustomException(e.Message);
         }
     }
     else
     {
         throw new NoteArgumentException();
     }
 }
Example #14
0
        public bool DeleteRole(UserRoleDTO UserRoleDTO)
        {
            DatabaseManager oDB;

            oDB = new DatabaseManager();
            string sProcName = "up_DeleteRole";

            oDB.DbCmd = oDB.GetStoredProcCommand(sProcName);
            oDB.DbDatabase.AddInParameter(oDB.DbCmd, "@iRoleID", DbType.Int32, UserRoleDTO.UserRoleId);
            try
            {
                oDB.ExecuteNonQuery(oDB.DbCmd);
                //return true;
            }
            catch (Exception e)
            {
                GF.LogError("clsUserRoleHandler.DeleteRole", e.Message);
                return(false);
            }
            finally
            {
                oDB = null;
            }
            return(true);
        }
Example #15
0
        public ActionResult AddEmployee(EmployeeVM model)
        {
            // Check model state
            if (!ModelState.IsValid)
            {
                return(View("AddEmployee", model));
            }

            // Check if passwords match
            if (!model.password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "كلمة المرور غير مطابقة ");
                return(View("AddEmployee", model));
            }

            using (Db db = new Db())
            {
                // Make sure username is unique
                if (db.Employees.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", "الموظف  " + model.Username + " موجود مسبقا.");
                    model.Username = "";
                    return(View("AddEmployee", model));
                }

                // Create userDTO
                EmployeeDTO userDTO = new EmployeeDTO()
                {
                    FirstName   = model.FirstName,
                    LastName    = model.LastName,
                    PhoneNumber = model.PhoneNumber,
                    Username    = model.Username,
                    password    = model.password
                };

                // Add the DTO
                db.Employees.Add(userDTO);

                // Save
                db.SaveChanges();

                // Add to UserRolesDTO
                int id = userDTO.Id;

                UserRoleDTO userRolesDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRolesDTO);
                db.SaveChanges();
            }

            // Create a TempData message
            TempData["SM"] = "تمت إضافة  بيانات الموظف بنجاح";

            // Redirect
            return(RedirectToAction("AddEmployee"));
        }
Example #16
0
        public ActionResult CreateAccount(UserViewModel model)
        {
            // перевірка на валідність
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // перевірка відповідності пароля
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Password do not match!");
                return(View("CreateAccount", model));
            }

            using (DB db = new DB())
            {
                // перевірка імені на унікальність
                if (db.Users.Any(x => x.UserName.Equals(model.UserName)))
                {
                    ModelState.AddModelError("", $"Username {model.UserName} is taken.");
                    model.UserName = "";
                    return(View("CreateAccount", model));
                }

                // створюємо екземпляр класу UserDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    UserName     = model.UserName,
                    Password     = model.Password
                };

                // додаємо дані в модель
                db.Users.Add(userDTO);

                // зберігаємо дані
                db.SaveChanges();

                // додаємо роль користувачу
                int id = userDTO.ID;

                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserID = id,
                    RoleID = 2
                };

                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }

            // записуємо повідомлення в TempData
            TempData["SM"] = "You are now registered and can login.";

            // переадресовуємо користувача
            return(RedirectToAction("Login"));
        }
Example #17
0
        public bool UserRoleDelete(int userId, int roleId)
        {
            UserRoleCRUD userRoleCRUD = new UserRoleCRUD();
            UserRoleDTO  userRoleDTO  = new UserRoleDTO(0, userId, roleId);

            return(userRoleCRUD.Delete(userRoleDTO));
        }
Example #18
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public List <UserRoleDTO> GetUserRoles(int userId)
        {
            List <UserRoleDTO> retVal = new List <UserRoleDTO>();

            try
            {
                DataSet ds = new ProjectDB(Utility.ConfigurationHelper.GPD_Connection).GetUserRoles(userId);
                if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow dr in ds.Tables[0].Rows)
                    {
                        UserRoleDTO tempUserRole = new UserRoleDTO();
                        tempUserRole.UserId      = userId;
                        tempUserRole.GroupId     = Convert.ToInt32(dr["group_id"].ToString());
                        tempUserRole.GroupName   = dr["GroupName"].ToString();
                        tempUserRole.PartnerId   = dr["partner_id"].ToString();
                        tempUserRole.PartnerName = dr["PartnerName"].ToString();
                        retVal.Add(tempUserRole);
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error("Unable to Actctivate/Dactivate user for userId: " + userId, ex);
            }
            return(retVal);
        }
        public async Task <IActionResult> EditUsersInRole(string roleId)
        {
            var role = await roleManager.FindByIdAsync(roleId);

            ViewBag.roleId   = roleId;
            ViewBag.RoleName = role.Name;
            if (role == null)
            {
                ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
                return(NotFound());
            }
            var model = new List <UserRoleDTO>();

            foreach (var user in userManager.Users)
            {
                var userRoleDTO = new UserRoleDTO
                {
                    UserId   = user.Id,
                    UserName = user.UserName
                };
                if (await userManager.IsInRoleAsync(user, role.Name))
                {
                    userRoleDTO.IsSelected = true;
                }
                else
                {
                    userRoleDTO.IsSelected = false;
                }
                model.Add(userRoleDTO);
            }
            return(View(model));
        }
Example #20
0
        public ActionResult CreateAccount(UserVM model)
        {
            // Check model state
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // Check if passwords match
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Lozinka nije odgovarajuca!");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                // Make sure username is unique
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", "Korisnicko ime " + model.Username + " vec postoji!");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                // Create userDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    Username     = model.Username,
                    Password     = model.Password
                };

                // Add the DTO
                db.Users.Add(userDTO);

                // Save
                db.SaveChanges();

                // Add to UserRolesDTO
                int id = userDTO.Id;

                UserRoleDTO userRolesDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRolesDTO);
                db.SaveChanges();
            }

            // Create a TempData message
            TempData["SM"] = "Sada ste registrovani i mozete da se ulogujete!";

            // Redirect
            return(Redirect("~/account/login"));
        }
Example #21
0
        public ActionResult CreateAccount(UserVM model)
        {
            //Проверяем модель на валидность
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            //Проверяем соотвецтвие пароля
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Password does not match!");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                //Проверяем имя на уникальность
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", $"Username{model.Username} is taken!");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                //Создаем экземпрял класса UserDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName   = model.FirstName,
                    LastName    = model.LastName,
                    EmailAdress = model.EmailAdress,
                    PhoneNumber = model.PhoneNumber,
                    Username    = model.Username,
                    Password    = model.ConfirmPassword
                };

                //Добавляем данные в экземпляр класса (в модель)
                db.Users.Add(userDTO);

                //Сохраняем данные
                db.SaveChanges();

                //Добавляем роль пользователю
                int id = userDTO.Id;

                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }
            //Выводим cообщение в TempData
            TempData["SM"] = "You are now registered and can login";

            //Переадрессовываем пользователя
            return(RedirectToAction("Login"));
        }
Example #22
0
        public ActionResult CreateAccount(UserVM model)
        {
            //check model on validation
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            //check confirm passord
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Passwords do not match!");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                //check name on unique
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", $"Username {model.Username} is taken.");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                //create example classes UserDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    Username     = model.Username,
                    Password     = model.Password
                };

                //Add data in model
                db.Users.Add(userDTO);

                //save data
                db.SaveChanges();

                //add role user
                int id = userDTO.Id;

                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }
            //note message in TempData
            TempData["SM"] = "You are now registered and can login.";

            //redirect user
            return(RedirectToAction("Login"));
        }
Example #23
0
        public ActionResult CreateAccount(UserVM model)
        {
            // sprawdzenie model state
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // sprawdzenie hasła
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Hasła nie pasują do siebie");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                // sprawdzenie czy nazwa uzytkownika jest unikalna
                if (db.Users.Any(x => x.UserName.Equals(model.UserName)))
                {
                    ModelState.AddModelError("", "Nazwa użytkownika " + model.UserName + " jest już zajęta");
                    model.UserName = "";
                    return(View("CreateAccount", model));
                }

                // utworzenie uzytkownika
                UserDTO usserDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    UserName     = model.UserName,
                    Password     = model.Password,
                };

                // dodanie uzytkownika
                db.Users.Add(usserDTO);
                // zapis na bazie
                db.SaveChanges();

                // dodanie roli dla uzytkownika
                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = usserDTO.Id,
                    RoleId = 2
                };

                // dodanie roli
                db.UserRoles.Add(userRoleDTO);
                // zapis na bazie
                db.SaveChanges();
            }

            // TempData komunikat
            TempData["SM"] = "Jesteś teraz zarejestrowany i możesz się zalogować!";


            return(Redirect("~/account/login"));
        }
Example #24
0
 public bool Delete(UserRoleDTO userRole)
 {
     using (IDbConnection connection = Connection.GetConnection())
     {
         string sqlExpression = "User_Role_Delete @UserID, @RoleID";
         return(connection.Query <bool>(sqlExpression, userRole).FirstOrDefault());
     }
 }
    private void Delete()
    {
        if (!base.ValidateIfCommandAllowed(Request.Url.AbsoluteUri, ENums.PageCommand.Delete))
        {
            return;
        }

        if (ValidateValues() == false)
        {
            return;
        }
        bool bActionCompleted = false;
        int  Id = 0;

        int.TryParse(hfId.Value, out Id);
        if (Id == 0)
        {
            lblStatus.Text = "Please click on edit button again.";
            return;
        }
        UserRoleMaster oUserRoleMaster = new UserRoleMaster();
        UserRoleDTO    oUserRoleData   = new UserRoleDTO();

        oUserRoleData.UserRoleId = Id;

        /*
         *
         * CHECK IF THE UserRole WHICH IS TO BE DELETED HAS ANY ASSOCIATED RECORDS...IF YES, MOVE OUT OF THE FUNCTION ELSE PROCEED
         * IF THE OUTPUT OF sMessage IS "", THEN RECORD CAN BE DELETED, ELSE NOT
         *
         */
        string sMessage = "";

        GF.HasRecords(Convert.ToString(Id), "UserRole", out sMessage);
        if (sMessage != "")
        {
            base.DisplayAlert(sMessage);
            btnDelete.Enabled = true;
        }
        else
        {
            bActionCompleted = oUserRoleMaster.Delete(oUserRoleData);
            if (bActionCompleted == true)
            {
                base.DisplayAlert("The record has been deleted successfully");
                txtUserRoleName.Text = string.Empty;
                hfId.Value           = string.Empty;
            }
            else
            {
                base.DisplayAlert("Error Occured while deletion: Please refer to the error log.");
            }
            //lblStatus.Text = "Error Occured while deletion: Please refer to the error log.";
        }
        RefreshGrid();
        oUserRoleData   = null;
        oUserRoleMaster = null;
    }
Example #26
0
        public ActionResult CreateAccount(UserVM model)
        {
            //check model state
            if (!ModelState.IsValid)
            {
                return(View("createAccount", model));
            }
            //check if passwords match
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Passwords do not match.");
                return(View("CreateAccount", model));
            }

            using (CmsShoppingCartContext db = new CmsShoppingCartContext())

            {
                //make sure username is unique
                if (db.Users.Any(x => x.UserName.Equals(model.UserName))) //if theres a match its a problem
                {
                    ModelState.AddModelError("", "Username" + model.UserName + "is taken");
                    model.UserName = "";
                    return(View("CreateAccount", model));
                }

                //create user DTO
                UserDTO userDTO = new UserDTO()
                {
                    //initialise its fileds
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    UserName     = model.UserName,
                    Password     = model.Password
                };

                //Add the DTO
                db.Users.Add(userDTO);
                //Save
                db.SaveChanges();

                //Add to userRolesDTO  >>>of 2 which is for user for anyone who signs in
                int id = userDTO.Id;

                UserRoleDTO userRolesDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };

                db.UserRoles.Add(userRolesDTO);
            }
            //Crate a TempData message
            TempData["SM"] = "You are now registered and can login";

            //Redirect
            return(Redirect("~/account/login"));
        }
        public ActionResult CreateAccount(UserVM model)
        {
            //проверяем модель на валидность
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Password do not match");
                return(View("CreateAccount", model));
            }

            //проверяем соответсвие пароля
            using (Db db = new Db())
            {
                //проверяем имя на уникальность
                if (db.Users.Any(x => x.Username.Equals(model.Username)))
                {
                    ModelState.AddModelError("", $"Username {model.Username} is taken.");
                    model.Username = "";
                    return(View("CreateAccount", model));
                }

                //создаем экземпляр класса UserDTO
                UserDTO userDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    Username     = model.Username,
                    Password     = model.Password
                };

                //добавляем данные в модель
                db.Users.Add(userDTO);

                //сохраняем данные
                db.SaveChanges();

                //добавляем роль пользователю
                int         id          = userDTO.Id;
                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = id,
                    RoleId = 2
                };
                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }

            //записать сообщение в TempData
            TempData["Successful message"] = "You are nowregistered and can login.";

            //переадресовываем пользователя
            return(RedirectToAction("Login"));
        }
Example #28
0
        public ActionResult CreateAccount(UserVM model)
        {
            // checking model state
            if (!ModelState.IsValid)
            {
                return(View("CreateAccount", model));
            }

            // checking password
            if (!model.Password.Equals(model.ConfirmPassword))
            {
                ModelState.AddModelError("", "Paswords must be exactly the same.");
                return(View("CreateAccount", model));
            }

            using (Db db = new Db())
            {
                // username unique validation
                if (db.Users.Any(x => x.UserName.Equals(model.UserName)))
                {
                    ModelState.AddModelError("", "UserName: "******" Alredy exists.");
                    model.UserName = "";
                    return(View("CreateAccount", model));
                }

                // user creation
                UserDTO usserDTO = new UserDTO()
                {
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    EmailAddress = model.EmailAddress,
                    UserName     = model.UserName,
                    Password     = model.Password,
                };

                // adding user
                db.Users.Add(usserDTO);
                db.SaveChanges();

                // adding role for user
                UserRoleDTO userRoleDTO = new UserRoleDTO()
                {
                    UserId = usserDTO.Id,
                    RoleId = 2
                };

                // adding role
                db.UserRoles.Add(userRoleDTO);
                db.SaveChanges();
            }

            // TempData komunikat
            TempData["SM"] = "User has been registered! Please go to Login";


            return(Redirect("~/account/login"));
        }
Example #29
0
 public void Add(UserRoleDTO DTO)
 {
     using (var container = new InventoryContainer())
     {
         PayUserRole gur = new PayUserRole();
         container.PayUserRoles.AddObject((PayUserRole)DTOMapper.DTOObjectConverter(DTO, gur));
         container.SaveChanges();
     }
 }
Example #30
0
        private UserRoleDTO GetUserRoleDetails(int userRoleId)
        {
            UserRoleDTO    userRoleDto    = new UserRoleDTO();
            UserRoleMaster userRoleMaster = new UserRoleMaster();

            userRoleDto.UserRoleId   = userRoleId;
            userRoleDto.UserRoleName = userRoleMaster.GetUserRoleName(userRoleId);
            return(userRoleDto);
        }
 UserRoleDTO ReadUserRoleDTO([NotNull] IDataRecord r)
 {
     UserRoleDTO x = new UserRoleDTO();
     x.UserRoleId = (int) r["UserRoleId"];
     x.Name = (string) r["Name"];
     x.Description = GetNullableRef<string>(r["Description"]);
     PostReadUserRoleDTO(x,r);
     return x;
 }
Example #32
0
 public static UserRoleDTO CreateUserRoleDTO(int ID, int userId, int roleId)
 {
     UserRoleDTO userRoleDTO = new UserRoleDTO();
     userRoleDTO.Id = ID;
     userRoleDTO.UserId = userId;
     userRoleDTO.RoleId = roleId;
     return userRoleDTO;
 }