public ActionResult <RegisterResponseDto> Register([FromBody] RegisterRequestDto registerRequestDto)
{
if (registerRequestDto == null)
{
Logger.LogError(new ArgumentNullException(nameof(registerRequestDto)), "");
throw new ArgumentNullException(nameof(registerRequestDto));
}
var requestValid = _userService.RegisterRequestValid(registerRequestDto);
if (requestValid != RegisterResult.Success)
{
return(Ok(new RegisterResponseDto {
RegisterSuccess = requestValid
}));
}
var registerResponseDto = _authenticationService.CreateUser(registerRequestDto);
var token = _authenticationService.CreateToken(registerResponseDto.UserInfo.UserId);
registerResponseDto.Token = token;
var refreshToken = _authenticationService.CreateRefreshToken(registerResponseDto.UserInfo.UserId);
SetCookie("refresh_token", refreshToken, 60 * 24 * 180); // Lasts 180 days
return(Ok(registerResponseDto));
}
public RegisterResponseDto CreateUser(RegisterRequestDto registerRequestDto)
{
if (registerRequestDto == null)
{
return(null);
}
var newUser = new WebUser
{
UserId = "user:"******"{0:yyyyMMddHHmmssffff}", DateTime.UtcNow),
Email = registerRequestDto.Email,
Firstname = registerRequestDto.Firstname,
Lastname = registerRequestDto.Lastname,
Username = registerRequestDto.Username,
Permission = WebUserPermission.User
};
var newPw = PasswordHasher.Hash(registerRequestDto.Password);
newUser.PasswordHash = newPw;
if (_userRepository.AddUser(newUser))
{
SendEmailConfirmationLink(newUser);
return(newUser.ToRegisterResponseDto());
}
return(new RegisterResponseDto {
RegisterSuccess = RegisterResult.Unknown
});
}
public object Register(RegisterRequestDto req)
{
string retMsg;
if (req.DeviceTokens.Any(e => e.ChannelId == 0 || string.IsNullOrWhiteSpace(e.DeviceToken)))
{
return(this.Error(ErrCode.ParameterError, "DeviceTokens中有参数为空"));
}
if (req.DeviceTokens.Select(e => e.ChannelId).Distinct().Count() < req.DeviceTokens.Count())
{
return(this.Error(ErrCode.ParameterError, "DeviceTokens中有相同的ChannelId"));
}
if (string.IsNullOrWhiteSpace(req.DeviceId))
{
return(this.Error(ErrCode.ParameterError, "DeviceId不能为空"));
}
var ret = _registerServiceLazy.Value.Register(req, out retMsg);
if (ret == ErrCode.Sucess || ret == ErrCode.DataIsExist)
{
return(this.Success(true));
}
return(this.Error(ret, retMsg));
}
public async Task <string> Register(RegisterRequestDto model)
{
_authValidationService.ValidateRegisterViewModel(model);
var newUser = new WorkshopUser
{
UserName = model.UserName,
Email = model.Email
//FirstName = model.FirstName,
//LastName = model.LastName
};
var result = await _userManager.CreateAsync(newUser, model.Password);
await _userManager.AddToRoleAsync(newUser, WorkshopRoleNames.Client);
if (!result.Succeeded)
{
throw new RegisterFailedException(
$"An error occured while registering user: {string.Join(",", result.Errors.Select(x => x.Description))}");
}
await _signInManager.SignInAsync(newUser, false);
return(await GetToken(newUser));
}
public IActionResult Register([FromBody] RegisterRequestDto userRegisterRequestData)
{
// Validates data from form
if (ModelState.IsValid)
{
if (_accountService.IsEmailExists(userRegisterRequestData.Email))
{
ModelState.AddModelError("emailRemote", "Such email is already exists");
}
if (_accountService.IsUsernameExists(userRegisterRequestData.Username))
{
ModelState.AddModelError("usernameRemote", "Such username is already in use");
}
}
// Validates all data including business logic
if (ModelState.IsValid)
{
var user = _mapper.Map <User>(userRegisterRequestData);
_accountService.Create(user, userRegisterRequestData.Password);
return(Ok());
}
return(BadRequest(ModelState));
}
public async Task RegisterAsync(RegisterRequestDto request, string origin)
{
await _registerRequestValidator.ValidateAndThrowAsync(request);
// validate
if (_dbContext.Accounts.Any(x => x.Email == request.Email))
{
// send already registered error in email to prevent account enumeration
SendAlreadyRegisteredEmail(request.Email, origin);
return;
}
// map model to new account object
var account = _mapper.Map <Account>(request);
// first registered account is an admin
var isFirstAccount = _dbContext.Accounts.Count() == 0;
account.Role = isFirstAccount ? Role.Admin : Role.User;
account.CreatedDate = DateTime.UtcNow;
account.VerificationToken = RandomTokenString();
// hash password
account.PasswordHash = BC.HashPassword(request.Password);
// save account
_dbContext.Accounts.Add(account);
await _dbContext.SaveChangesAsync();
// send email
SendVerificationEmail(account, origin);
}
public async Task <UserResponseDto> Register(RegisterRequestDto dto)
{
await this.UserExists(dto.Username);
this.ValidatePassword(dto.Password);
var passwordResult = PasswordEncrypt.ComputeHash(dto.Password);
var user = new User
{
Username = dto.Username,
FirstName = dto.FirstName,
LastName = dto.LastName,
Role = Role.User,
Password = passwordResult.Hash,
PasswordSalt = passwordResult.Salt
};
this.dbContext.Users.Add(user);
await this.dbContext.SaveChangesAsync();
return(new UserResponseDto
{
Id = user.Id,
Username = user.Username,
Token = this.tokenService.CreateToken(user),
Role = user.Role,
FirstName = user.FirstName,
LastName = user.LastName
});
}
public async Task <IActionResult> RegisterWithoutEmailVerification([FromBody] RegisterRequestDto request)
{
if (!ModelState.IsValid)
{
return(ValidationProblem(ModelState));
}
// Map dto to entity
var user = _mapper.Map <ApplicationUser>(request);
// Create new user. This should incorporate a process to verify that the user owns the email address.
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
var userDto = _mapper.Map <UserDto>(user);
userDto.Roles = (await _userManager.GetRolesAsync(user)).ToArray();
return(Created($"/{ApiRoot}account", userDto));
}
else
{
var errorDto = new ErrorDto();
errorDto.AddIdentityErrors(result.Errors);
return(BadRequest(errorDto));
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestDto userRequestDto)
{
if (userRequestDto == null || !ModelState.IsValid)
{
return(BadRequest());
}
var user = new ApplicationUser
{
UserName = userRequestDto.Email,
Email = userRequestDto.Email,
Name = userRequestDto.Name,
PhoneNumber = userRequestDto.PhoneNo,
EmailConfirmed = true
};
var result = await UserManager.CreateAsync(user, userRequestDto.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new ApiResponseDto
{
Errors = errors, IsSuccessful = false
}));
}
return(Created("", new ApiResponseDto {
IsSuccessful = true
}));
}
public async Task Register(RegisterRequestDto dto)
{
var res = await _httpClient.PostAsync("/auth/register", Json(dto))
.ConfigureAwait(false);
res.EnsureSuccessStatusCode();
}
private PageRoutes.RegisterPage CreateRegisterPage(ServiceProvider provider, RegisterRequestDto request)
{
var page = new PageRoutes.RegisterPage();
provider.InjectDependencies(page);
page.Request = request;
return(page);
}
public async Task Register(RegisterRequestDto registerRequest)
{
var result = await _httpClient.PostAsJsonAsync("auth/Register", registerRequest);
if (result.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
throw new Exception(await result.Content.ReadAsStringAsync());
}
result.EnsureSuccessStatusCode();
}
public void Register_Returns_NoInput()
{
var user = new RegisterRequestDto();
var mockUserService = new Mock <IPersonService>();
mockUserService.Setup(m => m.Register(null)).Returns(() => null);
var controller = new CustomerController(mockUserService.Object, null, null, null);
var result = controller.Register(user);
Assert.IsType <BadRequestObjectResult>(result.Result);
}
private RegisterResponseDto RegisterTest(RegisterRequestDto req)
{
return(new RegisterResponseDto
{
Age = 12,
Email = "*****@*****.**",
FirstName = "test",
Gender = 1,
LastName = "test last"
});
}
public async Task RegisterUser_ValidationError()
{
//arrange
RegisterRequestDto req = new RegisterRequestDto();
//act
var validationResults = new List <ValidationResult>();
var actual = Validator.TryValidateObject(req, new ValidationContext(req), validationResults, true);
//assert
Assert.Equal("The firstName field is required.", validationResults[0].ErrorMessage);
Assert.Equal("The email field is required.", validationResults[1].ErrorMessage);
Assert.Equal("The password field is required.", validationResults[2].ErrorMessage);
}
public async Task <IActionResult> Register([FromBody] RegisterRequestDto request)
{
string?userId = null;
string?userToken = null;
if (request.CreateUser)
{
userId = Guid.NewGuid().ToString();
var update = request.ToUpdate();
var user = await userStore.UpsertAsync(App.Id, userId, update, HttpContext.RequestAborted);
if (request.Topics?.Any() == true)
{
var subscription = new SubscriptionUpdate();
subscription.TopicSettings[Providers.WebPush] = new NotificationSetting
{
Send = true
};
if (!string.IsNullOrEmpty(request.EmailAddress))
{
subscription.TopicSettings[Providers.Email] = new NotificationSetting
{
Send = true
};
}
foreach (var topic in request.Topics)
{
subscription.TopicPrefix = topic;
await subscriptionStore.SubscribeWhenNotFoundAsync(App.Id, subscription, HttpContext.RequestAborted);
}
}
userToken = user.ApiKey;
}
var response = new RegisterResponseDto
{
PublicKey = webPushService.PublicKey,
UserId = userId,
UserToken = userToken
};
return(Ok(response));
}
public ErrCode Register(RegisterRequestDto dto, out string retMsg)
{
retMsg = "";
try
{
int brandId;
if (!_tokenBrandLogic.MatchBrandId(dto.Brand, out brandId))
{
return(ErrCode.DataIsnotExist);
}
int systemType = brandId == APPLE_BRAND_ID ? 0 : 1;
//获取通过RToken获取注册列表
var tokenBrandList = _pushTokenBrandService.GetTokenBrandListByTokenAsync(dto.Token).Result;
var tokenBrands = tokenBrandList.Where(e => e.SystemType == systemType).OrderByDescending(e => e.UpdateAt).ToList();
var tokenBrand = tokenBrands.SingleOrDefault(e => e.AppId == dto.AppId && e.BrandId == brandId && e.DeviceId == dto.DeviceId);
if (tokenBrands.Count() >= 3)
{
for (int i = 2; i < tokenBrands.Count(); i++)
{
int deleteRow = _pushTokenBrandService.DeleteTokenBrandByIdAsync(tokenBrands[i].Id).Result;
}
}
//检查AppId是否存在
if (!_tokenBrandLogic.CheckAppId(dto.AppId.Value, out retMsg))
{
return(ErrCode.AppNotExist);
}
//清除设备之前注册的用户信息，避免设备收到别的用户的消息。
_pushTokenBrandService.TryClearDeviceOldUserAsync(dto.DeviceId, dto.Token).Wait();
RegisterRequestDomainModel model = _mapper.Map <RegisterRequestDomainModel>(dto);
model.SystemType = systemType;
model.BrandId = brandId;
var ret = _pushTokenBrandService.InsertTokenBrandAsync(model).Result;
if (ret > 0)
{
return(ErrCode.Sucess);
}
return(ErrCode.Failure);
}
catch (Exception ex)
{
retMsg = ex.Message;
return(ErrCode.Failure);
}
}
public void RegisterReturnsOkOnCorrectData()
{
var registerRequest = new RegisterRequestDto()
{
Email = "*****@*****.**",
Username = "******",
Password = "******",
PasswordConfirm = "password"
};
AccountController controller = this.AccountControllerInstance;
IActionResult result = controller.Register(registerRequest);
Assert.IsType <OkResult>(result);
}
public async Task <IActionResult> Register([FromBody] RegisterRequestDto model, CancellationToken ct)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok());
}
return(BadRequest(result.Errors));
}
public void Register_Returns_Already_Exists()
{
var person = new Person {
Username = "******"
};
var user = new RegisterRequestDto {
Name = "tom", Username = "******", Password = "******"
};
var mockUserService = new Mock <IPersonService>();
mockUserService.Setup(m => m.FindPersonByUsername(person.Username)).ReturnsAsync(person);
var controller = new CustomerController(mockUserService.Object, null, null, null);
var result = controller.Register(user);
Assert.IsType <BadRequestObjectResult>(result.Result);
}
public async Task <IActionResult> PostRegister([FromBody] RegisterRequestDto registerRequestDto)
{
UsersEntity user = await this._authenticationService.RegisterAsync(registerRequestDto.ToEntity());
if (user == null)
{
return(this.BadRequest());
}
const int expiryMinutes = 30;
DateTime expiryDate = DateTime.Now.AddMinutes(expiryMinutes);
string jwtToken = this._jwtService.GenerateToken(user, expiryMinutes);
return(this.Ok(new JwtDetails(jwtToken, expiryDate)));
}
public void RegisterReturnsBadRequestOnInvalidData()
{
var registerRequest = new RegisterRequestDto()
{
Email = "*****@*****.**",
Username = "******",
Password = "******",
PasswordConfirm = "password"
};
AccountController controller = this.AccountControllerInstance;
controller.ModelState.AddModelError("error", "error");
IActionResult result = controller.Register(registerRequest);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task <IActionResult> Register(RegisterRequestDto parameters)
{
var user = new ApplicationUser();
user.UserName = parameters.UserName;
var result = await _userManager.CreateAsync(user, parameters.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.FirstOrDefault()?.Description));
}
return(await Login(new LoginRequestDto
{
UserName = parameters.UserName,
Password = parameters.Password
}));
}
public ApiResponseDto <RegisterRequestDto> Register(UserDto registerDto)
{
var user = BUser.RegisterRequest(registerDto);
if (user != null)
{
RegisterRequestDto login = new RegisterRequestDto()
{
Name = user.Name,
Surname = user.Surname,
UserName = user.UserName,
Password = user.Password,
PasswordConfirm = user.ConfirmPassword
};
return(ApiResponseDto <RegisterRequestDto> .SuccessEmpty());
}
return(ApiResponseDto <RegisterRequestDto> .FailedResponse("basarisiz"));
}
public IActionResult Register([FromBody] RegisterRequestDto request)
{
// Map dto to entity
var user = _mapper.Map <User>(request);
try
{
// Create new user. This should incorporate a process to verify that the user owns the email address.
var createdUser = _userService.Create(user, request.Password);
var responseUser = _mapper.Map <UserDto>(createdUser);
return(Created($"/{ApiRoot}account", responseUser));
}
catch (AppException ex)
{
// Return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task Post([FromBody] RegisterRequestDto loginRequestModel)
{
var user = new IdentityUser()
{
UserName = loginRequestModel.Username
};
var result = await _userManager.CreateAsync(user, loginRequestModel.Password);
if (!result.Succeeded)
{
if (result.Errors.Any(e => e.Code == "DuplicateUserName"))
{
throw new ArgumentException("Имя пользователя уже занято");
}
throw new Exception(string.Join(", ", result.Errors.Select(e => e.Description)));
}
}
public async Task <ActionResult> Register(RegisterRequestDto model)
{
var user = new User
{
Email = model.Email,
UserName = model.UserName
};
var result = await this._userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await this._userManager.AddToRoleAsync(user, GlobalConstants.UserRole);
return(Ok());
}
return(BadRequest(result.Errors));
}
public static UsersEntity ToEntity(this RegisterRequestDto dto)
{
return(new UsersEntity()
{
Blocked = false,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
Username = dto.Username,
FirstName = dto.FirstName,
Introduction = dto.Introduction,
LastName = dto.LastName,
Packages = new List <string>(),
Password = dto.Password,
ProfilePicture = string.Empty, // this will be populated but later
Stars = new List <string>(),
Teams = new List <string>(),
TeamsOwner = new List <string>()
});
}
public async Task <RegisterResponseDto> RegisterUser(RegisterRequestDto user)
{
try
{
//check if user already exists
var regUser = await _repository.GetUserByEmail(user.Email);
if (regUser != null)
{
throw new UserAlreadyRegisteredException();
}
User newUser = new User()
{
ID = new Guid(),
Age = user.Age,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Gender = user.Gender,
Password = _authHelper.HashPassword(user.Password),
Role = user.Role
};
var registeredUser = await _repository.AddAsync(newUser);
RegisterResponseDto userResponseDto = new RegisterResponseDto
{
FirstName = registeredUser.FirstName,
LastName = registeredUser.LastName,
Age = registeredUser.Age,
Email = registeredUser.Email,
Gender = registeredUser.Gender
};
return(userResponseDto);
}
catch (Exception ex)
{
//TODO handle error
throw ex;
}
}
public async Task <ActionResult> Register([FromBody] RegisterRequestDto register)
{
if (string.IsNullOrEmpty(register.Name) || string.IsNullOrEmpty(register.Username) ||
string.IsNullOrEmpty(register.Password))
{
return(NotFound(new ErrorResponse(ErrorTypes.DataMissing.EnumDescription())));
}
var doesExists = await personService.FindPersonByUsername(register.Username);
if (doesExists != null)
{
return(BadRequest(new ErrorResponse(ErrorTypes.UsernameExists.EnumDescription())));
}
var user = await personService.Register(new Person(register));
var registerMapper = mapper.Map <RegisterResponse>(user);
return(Ok(registerMapper));
}
