public ActionResult Edit(UserInputModel model)
        {
            if (this.ModelState.IsValid)
            {
                var user = this.ContestData.Users
                    .All()
                    .FirstOrDefault(u => u.UserName == model.UserName);

                if (user == null)
                {
                    return this.HttpNotFound();
                }

                user.UserName = model.UserName;
                user.FullName = model.FullName;
                user.Email = model.Email;
                user.PhoneNumber = model.PhoneNumber;

                this.ContestData.SaveChanges();

                return this.RedirectToAction("Index");
            }

            return this.View(model);
        }
Пример #2
0
        private async Task LoadUser()
        {
            var url   = $"users/{Id}";
            var model = await ApiService.GetAsync <UserModel>(url);

            user = new UserInputModel
            {
                Name     = model.Name,
                HourRate = model.HourRate
            };
        }
        public ActionResult EditingInline_Destroy([DataSourceRequest] DataSourceRequest request, UserInputModel userModel)
        {
            if (userModel != null)
            {
                var user = Mapper.Map<User>(userModel);
                this.Data.Users.Remove(user);
                this.Data.SaveChanges();
            }

            return this.Json(new[] { userModel }.ToDataSourceResult(request, this.ModelState));
        }
Пример #4
0
        public async Task <ActionResult <UserOutputModel> > Register(UserInputModel input)
        {
            var result = await this.identity.Register(input);

            if (!result.Succeeded)
            {
                return(BadRequest(result.Errors));
            }

            return(await Login(input));
        }
Пример #5
0
        public async Task <ActionResult <UserOutputModel> > Login(UserInputModel input)
        {
            var result = await this.identity.Login(input);

            if (!result.Succeeded)
            {
                return(BadRequest(result.Errors));
            }

            return(new UserOutputModel(result.Data.Token));
        }
 public void Dismissed(string result)
 {
     if (!string.IsNullOrEmpty(result))
     {
         var model = new UserInputModel();
         model.ButtonResponse = 1;
         model.UserInputText  = result;
         SL.Manager.PostDialog(_dialogSubmisionUrl, model, DialogSubmited);
         _dialogSubmisionUrl = null;
     }
 }
Пример #7
0
        public void CreateUser(UserInputModel inputUser)
        {
            var user = new User
            {
                Username = inputUser.Username,
                Password = ComputeHash(inputUser.Password),
                Email    = inputUser.Email
            };

            db.Users.Add(user);
            db.SaveChanges();
        }
        public async Task <IUser> Register(UserInputModel userInput)
        {
            var user = new User(userInput.Email);

            var identityResult = await this.userManager.CreateAsync(user, userInput.Password);

            var errors = identityResult.Errors.Select(e => e.Description);

            return(identityResult.Succeeded
                ? user
                : throw new UserCreationFailedException("User Creation Failed!"));
        }
Пример #9
0
        public async Task <Result> Register(UserInputModel userInput)
        {
            var user = new User(userInput.Email);

            var identityResult = await this.userManager.CreateAsync(user, userInput.Password);

            var errors = identityResult.Errors.Select(e => e.Description);

            return(identityResult.Succeeded
                ? Result.Success
                : Result.Failure(errors));
        }
Пример #10
0
        public userRepositoryTests()
        {
            userRepository = new  UserRepository(RepositoryConfiguration.ConnFactory(), RepositoryConfiguration.DatabaseName, RepositoryConfiguration.CollectionUser);

            userInputModel = new UserInputModel {
                Name          = "nome usuario",
                Password_Text = "password",
                NumberSalt    = 70,
                Interation    = 10101,
                Nhash         = 70
            };
        }
Пример #11
0
 public IActionResult EditUser(int id, [FromBody] UserInputModel User)
 {
     // Check if input model is valid, output all errors if not
     if (!ModelState.IsValid)
     {
         IEnumerable <string> errorList = ModelState.Values.SelectMany(v => v.Errors).Select(x => x.ErrorMessage);
         throw new InputFormatException("User input model improperly formatted.", errorList);
     }
     // Edit user if input model was valid
     _userService.EditUser(id, User);
     return(NoContent());
 }
Пример #12
0
        public IActionResult Login([FromBody] UserInputModel model)
        {
            var user = _userService.Validate(model.UserName, model.Password);

            if (user == null)
            {
                return(BadRequest("Acceso Denegado Usuario y/o contraseña incorrectos"));
            }
            var response = _jwtService.GenerateToken(user);

            return(Ok(response));
        }
Пример #13
0
        public void RegisterUser(UserInputModel model)
        {
            var user = new User
            {
                Username = model.Username,
                Email    = model.Email,
                Password = ComputeHash(model.Password)
            };

            this.db.Users.Add(user);
            this.db.SaveChanges();
        }
Пример #14
0
        //Edit user with new model.
        public void EditUser(UserInputModel model)
        {
            var entityModel = (from u in _db.Users
                               where u.UserID.Equals(model.UserID)
                               select u).SingleOrDefault();

            if (model.FirstName != null)
            {
                entityModel.FirstName = model.FirstName;
            }

            if (model.LastName != null)
            {
                entityModel.LastName = model.LastName;
            }

            var address = new AddressModel();

            if (model.Address.StreetName != null)
            {
                address.StreetName = model.Address.StreetName;
            }

            if (model.Address.HouseNumber != 0)
            {
                address.HouseNumber = model.Address.HouseNumber;
            }

            if (model.Address.City != null)
            {
                address.City = model.Address.City;
            }

            if (model.Address.Zip != 0)
            {
                address.Zip = model.Address.Zip;
            }

            if (model.Address.Country != null)
            {
                address.Country = model.Address.Country;
            }

            if (model.Image != null)
            {
                entityModel.Image = model.Image;
            }

            entityModel.Address = address;

            _db.Users.Update(entityModel);
            _db.SaveChanges();
        }
Пример #15
0
        public ActionResult <UserViewModel> Save(UserInputModel userInput)
        {
            var user     = MapUser(userInput);
            var response = _userService.Save(user);

            if (response.Object == null)
            {
                return(BadRequest(response.Message));
            }

            return(Ok(new UserViewModel(response.Object)));
        }
Пример #16
0
 public IHttpActionResult CreateUser(UserInputModel inputModel)
 {
     try
     {
         this.userService.CreateUser(inputModel);
         return(this.Ok("Successfully created"));
     }
     catch (Exception ex)
     {
         return(this.BadRequest(ex.Message));
     }
 }
Пример #17
0
        public async Task <Result <User> > Register(UserInputModel userInput)
        {
            User user = this.mapper.Map <User>(userInput);

            var identityResult = await this.userManager.CreateAsync(user, userInput.Password);

            var errors = identityResult.Errors.Select(e => e.Description);

            return(identityResult.Succeeded
                ? Result <User> .SuccessWith(user)
                : Result <User> .Failure(errors));
        }
        public async Task <IActionResult> EditProfile(string id, string firstName, string lastName, string streetName, int houseNumber, string city, int zip, string country)
        {
            //Creates new AddressModel of the user inputs.
            var address = new AddressModel()
            {
                StreetName  = streetName,
                HouseNumber = houseNumber,
                City        = city,
                Zip         = zip,
                Country     = country
            };

            //Creates the UserInputModel which can be partly or fully filled in.
            var newUser = new UserInputModel()
            {
                UserID    = id,
                FirstName = firstName,
                LastName  = lastName,
                Address   = address,
                Image     = null,
            };

            //Gets current user.
            var user = await _userManager.GetUserAsync(User);

            //Updates the current user file with the new info.
            _userService.EditUser(newUser);
            if (newUser.FirstName == null)
            {
                newUser.FirstName = _userService.GetUser(user.Id).FirstName;
            }
            if (newUser.LastName == null)
            {
                newUser.LastName = _userService.GetUser(user.Id).LastName;
            }

            //Returns all Claims of User.
            var allClaims = await _userManager.GetClaimsAsync(user);

            //Searches for the Name Claim.
            var userClaims = (from c in allClaims
                              where c.Type == "Name"
                              select c).ToList();

            //Removes them and replaces with The New Name.
            await _userManager.RemoveClaimsAsync(user, userClaims);

            await _userManager.AddClaimAsync(user, new Claim("Name", $"{newUser.FirstName} {newUser.LastName}"));

            //Returns the user to their user homepage after the changes.
            return(RedirectToAction("Index", "Account"));
        }
 public async Task <IActionResult> Register(RegisterFormModel model)
 => await this.Handle(
     async() =>
 {
     var mdl = new UserInputModel()
     {
         Email = model.Email, Password = model.Password
     };
     var result = await this.identityService
                  .Register(mdl);
 },
     success : RedirectToAction(nameof(UsersController.Login), "Users"),
     failure : View("../Users/Register", model));
Пример #20
0
        public IActionResult CreateUser([FromBody] UserInputModel User)
        {
            // Check if input model is valid, output all errors if not
            if (!ModelState.IsValid)
            {
                IEnumerable <string> errorList = ModelState.Values.SelectMany(v => v.Errors).Select(x => x.ErrorMessage);
                throw new InputFormatException("User input model improperly formatted.", errorList);
            }
            // Create new tape if input model was valid
            int id = _userService.CreateUser(User);

            return(CreatedAtRoute("GetUserById", new { id }, null));
        }
Пример #21
0
        /// <summary>
        /// Updates user
        /// </summary>
        /// <param name="Id">Id associated with user in system to update</param>
        /// <param name="User">New information on user to swap old information out for</param>
        public void EditUser(int Id, UserInputModel User)
        {
            var oldUser = _userRepository.GetAllUsers().FirstOrDefault(u => u.Id == Id);

            if (oldUser == null)
            {
                throw new ResourceNotFoundException($"User with id {Id} was not found.");
            }
            else
            {
                _userRepository.EditUser(Id, User);
            }
        }
Пример #22
0
        public async Task <ActionResult <int?> > UpdateUser([FromBody] UserInputModel model)
        {
            if (model == null || model.Id < 1)
            {
                return(BadRequest());
            }

            model.Password = Hashing.HashUserPassword(model.Password);
            User userModel = UserMapper.ToDataModel(model);
            int  id        = await userStorage.UserAddOrUpdate(userModel);

            return(Ok(id));
        }
Пример #23
0
        public ActionResult Create(UserInputModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            var user = this.Mapper.Map<User>(model);
            this.users.CreateUser(user, model.Password);

            this.TempData["Success"] = "User was successful added!";
            return this.RedirectToAction("Index");
        }
Пример #24
0
        public UserApiModel CreateUser(UserInputModel userInputModel)
        {
            if (userRepository.IsUsernameTaken(userInputModel.Username))
            {
                throw new UsernameAlreadyInUseException();
            }

            User user = mapper.Map <User>(userInputModel);

            User createdUser = userRepository.Add(user);

            return(mapper.Map <UserApiModel>(createdUser));
        }
Пример #25
0
        public async Task OnGetAsync([FromQuery] string username = null, string returnUrl = null, string registrationPageReturnUrl = null, string creyTicket = null, string theme = null, string mobile = null)
        {
            ReturnUrl = returnUrl;
            RegistrationPageReturnUrl = registrationPageReturnUrl;
            MobileMode = mobile;
            Input      = new UserInputModel {
                UserName = username
            };
            ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

            CreyTicket = creyTicket;
            this.UpdateTheme(theme);
        }
Пример #26
0
        public IActionResult Index(UserInputModel model)
        {
            var repo = _unitOfWork.GetRepository <Person>();

            var person = Mapper.Map <Person>(model);

            repo.Add(person);
            _unitOfWork.SaveChanges();

            var detail = Mapper.Map <UserDetailModel>(person);

            return(RedirectToAction("UserDetail", "Home", new { id = person.Id }));
        }
Пример #27
0
        public async Task <IActionResult> AddUser([FromBody] UserInputModel user)
        {
            var userId = this.GetUserId();

            if (user.Id != userId)
            {
                return(BadRequest());
            }

            await mediator.Send(new AddUserCommand(user.Id, user.Name, user.Email, user.ProfilePictureUrl));

            return(Ok());
        }
        public async Task <IActionResult> Edit(string id)
        {
            var userInputModel = new UserInputModel();

            if (!string.IsNullOrWhiteSpace(id))
            {
                var user = await UserService.GetUserAsync(id);

                userInputModel = user.ToInputModel();
            }

            return(await ReturnEditView(userInputModel));
        }
Пример #29
0
        public async Task <bool> Authenticate(UserInputModel userInputModel)
        {
            User user         = _mapper.Map <User> (userInputModel);
            User UserDatabase = await this.UserRepository.QueryByNamePasswordHash(user.Name);

            if (UserDatabase == null)
            {
                return(false);
            }

            user.SetSalt(UserDatabase.Salt);

            return(user.getHashPassword() == UserDatabase.Password_Hash);
        }
Пример #30
0
        public bool AddUser(UserInputModel userDetails)
        {
            UserDTO userDTO     = _mapper.Map <UserDTO>(userDetails);
            bool    isuserExist = IfUserExists(userDetails.Email);

            if (!isuserExist)
            {
                return(_repo.AddUser(userDTO));
            }
            else
            {
                return(false);
            }
        }
Пример #31
0
 public async Task CreateUserAsync(UserInputModel user)
 {
     try
     {
         UserValidation.InsertValidation(user);
         var userData = user.ToData(IdentityServerCryptography);
         await UserDataAccess.InsertAsync(userData);
     }
     catch (MongoWriteException ex)
     {
         ex.ThrowIfDuplicateKey(nameof(user.Email), $"O email '{user.Email}' já existe.");;
         throw new Exception("An error occours when create a user.");
     }
 }
Пример #32
0
        /*[HttpDelete("{identificacion}")]
         * public ActionResult<string> Delete(string identificacion)
         * {
         *  string mensaje = _personaService.Eliminar(identificacion);
         *  return Ok(mensaje);
         * }*/
        private User MapearUser(UserInputModel userInput)
        {
            var user = new User
            {
                UserName    = userInput.UserName,
                FirstName   = userInput.FirstName,
                LastName    = userInput.LastName,
                Password    = userInput.Password,
                MobilePhone = userInput.MobilePhone,
                Email       = userInput.Email
            };

            return(user);
        }
Пример #33
0
        public ActionResult Create(UserInputModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.View(model));
            }

            var user = this.Mapper.Map <User>(model);

            this.users.CreateUser(user, model.Password);

            this.TempData["Success"] = "User was successful added!";
            return(this.RedirectToAction("Index"));
        }
        public ActionResult EditingInline_Create([DataSourceRequest] DataSourceRequest request, UserInputModel userModel)
        {
            if (userModel != null && this.ModelState.IsValid)
            {
                // I create instace of new user because with automapper EF throws exception for validation errors
                var user = new User
                {
                    UserName = userModel.UserName,
                    Email = userModel.Email,
                    FullName = userModel.FullName,
                    PasswordHash = userModel.PasswordHash
                };

                var userManager = this.HttpContext.GetOwinContext().
                    GetUserManager<ApplicationUserManager>();

                userManager.PasswordValidator = new PasswordValidator
                {
                    RequiredLength = 2,
                    RequireNonLetterOrDigit = false,
                    RequireDigit = false,
                    RequireLowercase = false,
                    RequireUppercase = false
                };

                var userCreateResult = userManager.Create(user, user.PasswordHash);
                if (!userCreateResult.Succeeded)
                {
                    throw new Exception(string.Join("; ", userCreateResult.Errors));
                }

                // Set role
                this.AddOrRemoveAdministratorRoleForUser(user.Id, userModel.IsAdmin);

                this.Data.SaveChanges();

                // Sets return model data
                userModel.PasswordHash = user.PasswordHash;
                userModel.Id = user.Id;
            }

            return this.Json(new[] { userModel }.ToDataSourceResult(request, this.ModelState));
        }
Пример #35
0
        public void Logout()
        {
            IApplicationUnderTest app = Retrieve<IApplicationUnderTest>();

            var ha = app.GetHashCode();

            Navigation.NavigateTo<UserLoginController>(x => x.Home());
            return;
            //Navigation.NavigateTo(new UserInputModel());
            //Retrieve<IApplicationUnderTest>().RootUrl
            //Console.Write("h1");
            //IApplicationUnderTest app = Retrieve<IApplicationUnderTest>();
            IUrlRegistry urls = Retrieve<IApplicationUnderTest>().Urls;
            string str = "GET";
            object model = new UserInputModel();
            string categoryOrHttpMethod = str;
            //var url = urls.UrlFor(model, categoryOrHttpMethod);
            //Console.WriteLine("url: " + url);
            //Navigation.NavigateToUrl(urls.UrlFor<UserLoginController>(x => x.get_Home(new UserInputModel()), "GET"));
            Navigation.NavigateToUrl(urls.UrlFor(model, categoryOrHttpMethod));
            //Navigation.NavigateTo(new UserInputModel());
        }
Пример #36
0
        public FubuContinuation post_UserLogin(UserInputModel userInputModel)
        {
            var user = _usersService.GetUserByFirstAndLastName(userInputModel.FirstName, userInputModel.LastName);

            if (user == null)
            {
                user = _usersService.InsertUser(
                    new UserModel()
                    {
                        FirstName = userInputModel.FirstName,
                        LastName = userInputModel.LastName
                    });
            }

            var usersTasksVm = new UserTasksViewModel
            {
                CurrentUser = user
            };
            usersTasksVm.LoginTime = userInputModel.CurrentTime;
            _sessionState.Set(usersTasksVm);

            return FubuContinuation.RedirectTo(new UserInputValid(), "GET");
        }
        public ActionResult Edit(UserInputModel model, HttpPostedFileBase file)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(model);
            }

            string defaultAvatarName = null;

            if (file != null)
            {
                UploadResult result = this.UserManagement.SaveImage(file, this.UserId);
                if (!result.HasSucceed)
                {
                    this.ViewBag.Message = result.Error;
                    return this.View(model);
                }

                defaultAvatarName = result.Path;
            }

            //// TODO: try something:
            User databaseUser = this.usersService.GetById(this.UserId);
            databaseUser.FirstName = model.FirstName;
            databaseUser.LastName = model.LastName;
            databaseUser.Age = model.Age;
            databaseUser.Email = model.Email;
            databaseUser.AboutMe = model.AboutMe;
            databaseUser.SkypeName = model.SkypeName;
            databaseUser.LinkedInProfile = model.LinkedInProfile;
            databaseUser.FacebookAccount = model.FacebookAccount;

            if (defaultAvatarName != null || databaseUser.AvaratUrl != null)
            {
                databaseUser.AvaratUrl = Path.Combine("/Users", this.UserId, defaultAvatarName ?? databaseUser.AvaratUrl);
            }

            this.usersService.Update(databaseUser);

            return this.RedirectToAction("Index");
        }
        public ActionResult EditingInline_Update([DataSourceRequest] DataSourceRequest request, UserInputModel userModel)
        {
            if (userModel != null && this.ModelState.IsValid)
            {
                var userManager = this.HttpContext.GetOwinContext().
                    GetUserManager<ApplicationUserManager>();

                var userDb = this.Data
                            .Users
                            .All()
                            .FirstOrDefault(u => u.Id == userModel.Id);

                if (userDb != null)
                {
                    // Hash password with default user manager password hasher
                    userDb.PasswordHash = userManager.PasswordHasher.HashPassword(userModel.PasswordHash);
                    userDb.UserName = userModel.UserName;
                    userDb.Email = userModel.Email;
                    userDb.FullName = userModel.FullName;

                    this.Data.SaveChanges();

                    // Set role
                    this.AddOrRemoveAdministratorRoleForUser(userModel.Id, userModel.IsAdmin);

                    // Set new password to input model
                    userModel.PasswordHash = userDb.PasswordHash;
                }
                else
                {
                    return this.HttpNotFound();
                }
            }

            return this.Json(new[] { userModel }.ToDataSourceResult(request, this.ModelState));
        }
Пример #39
0
 public UserInputModel get_Home(UserInputModel userInputModel)
 {
     return userInputModel;
 }
Пример #40
0
 public IHttpActionResult CreateUser(UserInputModel user)
 {
     var newUser = new User(user.Email, user.FirstName, user.LastName);
     TripAppModel.Instance.Users.Add(newUser);
     return Created("/api/user/" + user.Email, newUser);
 }