Exemple #1
0
        public async Task NoContent()
        {
            var db = AddDbContext();

            db.Add(new User {
                UserId = 1
            });
            db.SaveChanges();
            var request    = new SaveUserRequest().SetStringProperties();
            var controller = GetController(1);
            var result     = await controller.Save("", request);

            Assert.IsType <NoContentResult>(result);
            db = Db;
            var hasher = Provider.GetService <PasswordHasher>();
            var token  = db.ConfirmationTokens.Single();
            var user   = db.Users.Single();

            Assert.Equal(request.Email, user.Email);
            Assert.Equal(request.FirstName, user.FirstName);
            Assert.Equal(request.LastName, user.LastName);
            Assert.True(hasher.Verify(user.Password, request.Password));
            Assert.Equal(UserStatus.PendingEmailConfirmation, user.Status);
            Assert.Equal(ConfirmationTokenType.Email, token.Type);
        }
Exemple #2
0
        /// <summary>
        /// 新建用户
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task <ResponseBase> AddUser(SaveUserRequest request)
        {
            if (await _sysUserBll.ExistSysUserByAccount(request.Account))
            {
                return(new ResponseBase().GetResponseError(StatusCode.User40002, "用户帐号已存在"));
            }
            var userRole = _sysUserRoleBll.GetSysUserRole(request.UserRoleId);

            if (userRole == null)
            {
                return(new ResponseBase().GetResponseError(StatusCode.UserRole30001, "角色不存在"));
            }
            var user = new SysUser()
            {
                NickName       = request.NickName,
                AuthorityValue = string.Empty,
                Account        = request.Account,
                UserRoleId     = request.UserRoleId,
                DataFlag       = (int)DataFlagEnum.Normal,
                DataLimitArea  = string.Empty,
                DataLimitShop  = string.Empty,
                LastLoginTime  = null,
                StatusFlag     = request.StatusFlag,
                Pwd            = CryptogramHelper.Encrypt3DES(request.Password),
                DataLimitType  = (int)DataLimitTypeEnum.Area
            };
            await _sysUserBll.AddUser(user);

            return(ResponseBase.Success());
        }
Exemple #3
0
        public void Create_New_User_Test()
        {
            var user = new User()
            {
                FirstName = "Joe",
                LastName = "Henss",
                UserName = "******",
                Password = Hasher.Hash("password"),
                PasswordSecurityQuestion = "Mother's maiden name",
                PasswordSecurityAnswer = "Hamilton"
            };

            var authenticationProvider = new AuthenticationService();
            var saveUserRequest = new SaveUserRequest() { User = user };

            var saveUserResponse = authenticationProvider.SaveUser(saveUserRequest);

            Assert.IsNotNull(saveUserResponse);
            Assert.AreEqual(ResponseStatus.Success, saveUserResponse.Status);

            var authenticateUserRequest = new AuthenticationRequest()
            {
                UserName = user.UserName,
                Password = user.Password
            };

            var authenticationResponse = authenticationProvider.AuthenticateUser(authenticateUserRequest);

            Assert.IsNotNull(authenticationResponse);
            Assert.AreEqual(ResponseStatus.Success, authenticationResponse.Status);
        }
Exemple #4
0
        /// <summary>
        /// 编辑用户
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task <ResponseBase> EditUser(SaveUserRequest request)
        {
            var user = await _sysUserBll.GetSysUser(request.UserId);

            if (user == null)
            {
                return(new ResponseBase().GetResponseError(StatusCode.User40001, "用户不存在"));
            }
            if (await _sysUserBll.ExistSysUserByAccount(request.Account, user.UserId))
            {
                return(new ResponseBase().GetResponseError(StatusCode.User40002, "用户帐号已存在"));
            }
            if (user.UserRoleId != request.UserRoleId)
            {
                var userRole = _sysUserRoleBll.GetSysUserRole(request.UserRoleId);
                if (userRole == null)
                {
                    return(new ResponseBase().GetResponseError(StatusCode.UserRole30001, "角色不存在"));
                }
            }
            user.NickName   = request.NickName;
            user.Account    = request.Account;
            user.UserRoleId = request.UserRoleId;
            user.StatusFlag = request.StatusFlag;
            await _sysUserBll.UpdateUser(user);

            return(ResponseBase.Success());
        }
        public SaveUserResponse SaveUser(SaveUserRequest request)
        {
            var response = new SaveUserResponse()
            {
                Request       = request,
                ResponseToken = Guid.NewGuid()
            };

            try
            {
                if (request.User?.Id == 0)
                {
                    response.User    = request.User;
                    response.User.Id = _repository.Add(request.User.MapToModel());
                    response.Success = true;
                }
                else if (request.User?.Id > 0)
                {
                    response.User    = _repository.Save(request.User.MapToModel()).MapToView();
                    response.Success = true;
                }
                else
                {
                    response.Success = false;
                }
            }
            catch (Exception ex)
            {
                response.Message = ex.Message;
                response.Success = false;
            }

            return(response);
        }
        public async Task <ActionResult> Update(long id, [FromBody] SaveUserRequest request)
        {
            try
            {
                var user = await context.Users
                           .AsNoTracking()
                           .SingleOrDefaultAsync(t => t.Id == id);

                if (user == null)
                {
                    return(NotFound());
                }

                var oldPassword = user.PasswordHash;
                user = mapper.Map <ApplicationUser>(request);
                user.PasswordHash = request.UpdatePassword ?
                                    passwordHasher.HashPassword(user, request.Password) :
                                    oldPassword;

                context.Update(user);
                await context.SaveChangesAsync();

                return(StatusCode(StatusCodes.Status204NoContent));
            }
            catch (DbUpdateConcurrencyException concurrencyEx)
            {
                logger.LogError(concurrencyEx.Message);
                return(StatusCode(StatusCodes.Status409Conflict, Constants.ErrorMessages.ConcurrencyErrorMessage));
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
        public void SetUp()
        {
            _database = new Mock <IDatabase>();
            _database.Setup(x => x.Save(It.IsAny <UserRecord>()));
            _database.Setup(x => x.Query <UserRecord>()).Returns(() => new List <UserRecord>
            {
                new UserRecord
                {
                    Id    = 1,
                    Email = "SOME_EMAIL_ADDRESS"
                }
            });

            var hasher = new Mock <IHasher>();

            hasher.Setup(x => x.Hash(It.IsAny <string>())).Returns(() => "SOME_HASHED_PASSWORD");

            var subject = new UserRepository(_database.Object, hasher.Object);

            var request = new SaveUserRequest
            {
                Email       = "SOME_EMAIL_ADDRESS",
                Password    = "******",
                PhoneNumber = "SOME_PHOME_NUMBER",
                Address     = "SOME_ADDRESS"
            };

            _result = subject.Save(request);
        }
Exemple #8
0
 /// <summary>
 /// 保存用户
 /// </summary>
 /// <param name="request"></param>
 /// <returns></returns>
 public async Task <ResponseBase> ProcessAction(SaveUserRequest request)
 {
     if (request.UserId > 0)
     {
         return(await EditUser(request));
     }
     return(await AddUser(request));
 }
Exemple #9
0
        public override async Task <SaveUserReply> SaveUser(SaveUserRequest request, ServerCallContext context)
        {
            var requestUser  = _mapper.Map <User>(request.User);
            var responseUser = await _userService.SaveUserAsync(requestUser);

            return(new SaveUserReply
            {
                User = _mapper.Map <UserMessage>(responseUser)
            });
        }
Exemple #10
0
        public override Task <SaveUserReply> Save(SaveUserRequest request, ServerCallContext context)
        {
            var result = new SaveUserReply();

            var flag = FakeUserInfoDb.Save(request.Name, request.Age);

            result.Code = 0;
            result.Msg  = "成功";

            return(Task.FromResult(result));
        }
Exemple #11
0
        public ServiceResult SaveUser([FromServices] IUserService userService, SaveUserRequest request)
        {
            if (CheckMainUserModify(request?.ID ?? 0, out ServiceResult errorResult))
            {
                return(errorResult);
            }

            var message = Mapper.Map <SaveUserMessage>(request);

            return(userService.Save(message));
        }
Exemple #12
0
 public async Task <ResponseBase> SaveUser([FromBody] SaveUserRequest request)
 {
     try
     {
         var action = new SaveUserAction(_sysUserBll, _sysUserRoleBll);
         return(await action.ProcessAction(request));
     }
     catch (Exception ex)
     {
         Log.Error(request, ex, this.GetType());
         return(ResponseBase.CodeError());
     }
 }
        public static SaveUserRequest ToRequest(this SaveUserWebRequest webRequest)
        {
            var request = new SaveUserRequest()
            {
                Id           = webRequest.Id,
                BirthDate    = webRequest.BirthDate,
                Username     = webRequest.Username,
                FirstName    = webRequest.FirstName,
                EmailAddress = webRequest.EmailAddress,
                LastName     = webRequest.LastName,
                Password     = webRequest.Password,
                MiddleName   = webRequest.MiddleName,
            };

            return(request);
        }
        public SqlCommand SaveUser(SaveUserRequest request)
        {
            var command = new SqlCommand();

            command.CommandText = "[dbo].[SaveUser]";
            command.CommandType = CommandType.StoredProcedure;

            command.Parameters.AddWithValue("@id", request.Id);
            command.Parameters.AddWithValue("@EmailAddress", request.EmailAddress);
            command.Parameters.AddWithValue("@Password", request.Password);
            command.Parameters.AddWithValue("@FirstName", request.FirstName);
            command.Parameters.AddWithValue("@MiddleName", request.MiddleName);
            command.Parameters.AddWithValue("@LastName", request.LastName);
            command.Parameters.AddWithValue("@UserName", request.Username);
            command.Parameters.AddWithValue("@BirthDate", request.BirthDate);

            return(command);
        }
        public async Task <ActionResult <SaveUserRequest> > Create([FromBody] SaveUserRequest entity)
        {
            try
            {
                var user = mapper.Map <ApplicationUser>(entity);
                user.PasswordHash = passwordHasher.HashPassword(user, entity.Password);

                await context.Users.AddAsync(user);

                await context.SaveChangesAsync();

                return(CreatedAtRoute(nameof(GetUserById), new { id = user.Id }, entity));
            }
            catch (Exception e)
            {
                logger.LogError(e.Message);
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
Exemple #16
0
        public IHttpActionResult Put(UserViewModel user)
        {
            var loggedUserId = HttpContext.Current.GetOwinContext().GetUserId();

            var request = new SaveUserRequest()
            {
                RequestToken = Guid.NewGuid(),
                UserId       = loggedUserId,
                User         = user.MapToView()
            };

            var usersResponse = _userService.SaveUser(request);

            if (!usersResponse.Success)
            {
                return(BadRequest(usersResponse.Message));
            }

            return(Ok(user = usersResponse.User.MapToViewModel()));
        }
Exemple #17
0
        public async Task <SaveUserResponse> SaveUser(SaveUserRequest request)
        {
            var response = new SaveUserResponse();

            try
            {
                var command = this.userSqlCommandFactory.SaveUser(request);
                var result  = await this.dataAccess.ExecuteNonQuery(command);

                response.Message = "Successfully registered user.";
                response.Success = true;
            }
            catch (Exception ex)
            {
                response.Errors.Add(ex.Message);
                response.Message = "Failed to register user.";
            }

            return(response);
        }
        public CreateUserResponse Register(string email, string password, string phone, string address)
        {
            var response = new CreateUserResponse();

            if (email.IsEmpty() || password.IsEmpty())
            {
                response.AddError(new Error {
                    Code = ErrorCodes.CredentialsAreIncomplete, UserMessage = "Email and password are required."
                });
                return(response);
            }

            if (!EmailValidator.IsValid(email))
            {
                response.AddError(new Error {
                    Code = ErrorCodes.EmailAddressIsNotValid, UserMessage = "Please provide a valid email address."
                });
                return(response);
            }

            var saveOrUpdateRequest = new SaveUserRequest
            {
                Email       = email,
                Password    = password,
                PhoneNumber = phone,
                Address     = address
            };
            var saveOrUpdateResponse = _userRepository.Save(saveOrUpdateRequest);

            if (saveOrUpdateResponse.HasError)
            {
                response.AddError(saveOrUpdateResponse.Error);
                return(response);
            }

            response.UserId = saveOrUpdateResponse.UserId;

            return(response);
        }
        public async Task <IActionResult> Save(string responseUrl, [FromBody] SaveUserRequest request)
        {
            var userId = this.GetUserId();
            var user   = await db.Users.SingleOrDefaultAsync(x => x.UserId == userId);

            if (!string.Equals(user.Email, request.Email, StringComparison.OrdinalIgnoreCase))
            {
                if (await db.Users.AnyAsync(x => x.Email == request.Email))
                {
                    return(this.BadRequest(nameof(SaveUserRequest.Email), EmailAlreadyInUse));
                }

                user.Email  = request.Email;
                user.Status = UserStatus.PendingEmailConfirmation;

                await SendEmailConfirmationToken(responseUrl, userId, user.Email);
            }

            if (!string.IsNullOrWhiteSpace(request.Password) && !string.Equals(user.Password, request.Password))
            {
                user.Password = passwordHasher.Hash(request.Password);
            }

            user.FirstName = request.FirstName;
            user.LastName  = request.LastName;

            if (request.Avatar != null && request.Avatar.Length > 0)
            {
                user.Avatar            = request.Avatar;
                user.AvatarContentType = request.AvatarContentType;
            }

            await db.SaveChangesAsync();

            return(NoContent());
        }
        public IActionResult Save([FromBody] SaveUserRequest user)
        {
            _saveUserCommand.Execute(user);

            return(NoContent());
        }
 public Task <SaveUserResponse> SaveUser(SaveUserRequest request)
 {
     throw new NotImplementedException();
 }
 public SaveUserResponse SaveUser(SaveUserRequest userInfo) => new SaveUserResponse
 {
     Success = true, Id = Guid.NewGuid()
 };
 /// <summary>
 /// Saves a user
 /// </summary>
 /// <param name="user"></param>
 /// <returns></returns>
 public SaveUserResponse SaveUser(SaveUserRequest userInfo)
 {
     return(new SaveUserResponse {
         Success = true, Id = Guid.NewGuid()
     });
 }