public async Task Post_Register()
{
var registerDto = new RegisterInputDto()
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var httpResponse = await _client.SendAsync(new HttpRequestMessage(HttpMethod.Post, "/account/register")
{
Content = new StringContent(System.Text.Json.JsonSerializer.Serialize(registerDto), Encoding.UTF8, "application/json")
});
httpResponse.EnsureSuccessStatusCode();
// Deserialize and examine results.
var response = await httpResponse.Content.ReadAsStringAsync();
var x = 20;
//var response = JsonConvert.DeserializeObject<SignupResponse>(stringResponse);
//Assert.Equal(_signupRequests[0].FullName, response.FullName);
//Assert.Equal(_signupRequests[0].Email, response.Email);
//Assert.Equal(_signupRequests[0].Role, response.Role);
//Assert.True(Guid.TryParse(response.Id, out _));
}
public async Task <IdentityResult> Register(RegisterInputDto model)
{
var user = new User {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = await _userManager.AddToRoleAsync(user, "UserTest");
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = $"{_client.Url}{_client.EmailConfirmationPath}?uid={user.Id}&code={System.Net.WebUtility.UrlEncode(code)}";
if (!_environment.IsDevelopment())
{
await _emailService.SendEmailConfirmationAsync(model.Email, callbackUrl);
}
}
return(result);
}
return(result);
}
public async Task <AppSrvResult <SimpleDto <string> > > Register(RegisterInputDto inputDto)
{
var exists = await _customerRepo.ExistAsync(t => t.Account == inputDto.Account);
if (exists)
{
return(Problem(HttpStatusCode.Forbidden, "该账号已经存在"));
}
var customer = _mapper.Map <Customer>(inputDto);
customer.ID = IdGenerater.GetNextId(IdGenerater.DatacenterId, IdGenerater.WorkerId);
var customerFinace = new CusFinance()
{
Account = customer.Account
,
Balance = 0
,
ID = customer.ID
};
await _cusManagerService.Register(customer, customerFinace);
return(new SimpleDto <string>(customer.ID.ToString()));
}
public async Task <SimpleDto <string> > Register(RegisterInputDto inputDto)
{
var exists = await _customerRepo.ExistAsync(t => t.Account == inputDto.Account);
if (exists)
{
throw new BusinessException(new ErrorModel(ErrorCode.Forbidden, "该账号已经存在"));
}
var customer = _mapper.Map <Customer>(inputDto);
customer.ID = IdGenerater.GetNextId(IdGenerater.DatacenterId, IdGenerater.WorkerId);
var customerFinace = new CusFinance()
{
Account = customer.Account
,
Balance = 0
,
ID = customer.ID
};
await _cusManagerService.Register(customer, customerFinace);
return(new SimpleDto <string> {
Result = customer.ID.ToString()
});
}
public async Task <IActionResult> Delete([FromBody] RegisterInputDto unregisterinput)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await TuristPlaceCategoryServise.UnRegister(unregisterinput);
return(Ok(result));
}
/// <summary>
/// 注册
/// </summary>
/// <returns></returns>
public async Task <IActionResult> Register(RegisterInputDto registerInputDto)
{
var id = _getId.GetId(EntityType.Account);
var result = await _accountApplication.CreatedAccount(id, registerInputDto.AccountName, registerInputDto.Password, registerInputDto.PhoneNumber);
if (result.Success)
{
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index", "Error"));
}
public ValidationOutputDto ValidateRegisterData(RegisterInputDto inputDto)
{
if (!EmailValidator.IsValid(inputDto.Email))
{
return(new ValidationOutputDto(false, "Podany email nie jest poprawny"));
}
return(!PasswordValidator.IsValid(inputDto.Password, inputDto.PasswordConfirm) ?
new ValidationOutputDto(false, "Hasło nie spełnia naszych wymagań lub nie jest takie same jak") :
new ValidationOutputDto(true, "Rejestracja zakończona poprawnie!"));
}
public async Task <IActionResult> Register([FromQuery] RegisterInputDto inputDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(inputDto));
}
var outputDto = await _accountService.Register(inputDto);
return(Ok(outputDto));
}
public async Task <string> UnRegister(RegisterInputDto unregisterinput)
{
var category = await FindCategory(unregisterinput.Category);
var place = await FindPlace(unregisterinput.TuristPlace);
var findrelation = await FindRegister(category, place);
var result = TuristPlaceCategoryRepository.Delete(findrelation.Id);
await TuristPlaceCategoryRepository.Save();
return(result);
}
public async Task <IActionResult> Register([FromBody] RegisterInputDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.Select(x => x.Errors.FirstOrDefault().ErrorMessage)));
}
var result = await _authService.Register(model);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(result.Errors.Select(x => x.Description)));
}
public async Task <string> Register(RegisterInputDto registerinput)
{
var findplace = await FindPlace(registerinput.TuristPlace);
var findcategory = await FindCategory(registerinput.Category);
var newregister = new TuristPlaceCategory()
{
CategoryId = findcategory.Id,
TuristPlaceId = findplace.Id
};
await IsReapited(newregister);
TuristPlaceCategoryRepository.Insert(newregister);
await TuristPlaceCategoryRepository.Save();
return("we add your relation");
}
public async Task <Result <RegisterOutputDto> > Handle(RegisterInputDto input, string tokenUrlTemplate)
{
if (!input.Validate(out ICollection <ResultError> validationErrors))
{
return(Result <RegisterOutputDto> .Fail(validationErrors));
}
var appUser = new AppUser()
{
UserName = input.Email, Email = input.Email
};
var result = await userManager.CreateAsync(appUser, input.Password);
if (!result.Succeeded)
{
if (result.Errors.Any(e => e.Code == "DuplicateEmail"))
{
return(Result <RegisterOutputDto> .Fail(Errors.ValidationEmailTaken(nameof(input.Email), input.Email)));
}
var errors = result.Errors.Select(e => new ResultError(ErrorCategory.Identity, e.Code, e.Description));
return(Result <RegisterOutputDto> .Fail(errors));
}
string token = await userManager.GenerateEmailConfirmationTokenAsync(appUser);
token = HttpUtility.UrlEncode(token);
string email = HttpUtility.UrlEncode(input.Email);
string url = string.Format(tokenUrlTemplate, token, email);
await emailSender.Send(new EmailMessage()
{
To = input.Email, From = "*****@*****.**", Subject = "Confirm Account", Body = $"<p>Thank you for registering. Please click the link (or copy into your browser) below to confirm your account.</p><br><br><a href='{url}'>{url}</a>"
});
// Add claims if needed
//await userManager.AddClaimAsync(appUser, new System.Security.Claims.Claim("userName", user.UserName));
//await userManager.AddClaimAsync(appUser, new System.Security.Claims.Claim("email", user.Email));
return(Result <RegisterOutputDto> .Success(new RegisterOutputDto()));
}
public async Task <RegisterOutputDto> Register(RegisterInputDto inputDto)
{
var validateData = _accountDomainService.ValidateRegisterData(inputDto);
if (!validateData.Passed)
{
return new RegisterOutputDto {
Passed = false, Message = validateData.Message
}
}
;
var account = await _unitOfWork.AccountRepository
.GetAsync(t => (t.Email == inputDto.Email ||
t.Name == inputDto.Name) &&
t.DateDeleted == null);
if (account != null)
{
return new RegisterOutputDto {
Passed = false, Message = "Konto z takim emailem lub nickiem już istnieje"
}
}
;
var accountModel = new AccountModel
{
Email = inputDto.Email,
Name = inputDto.Name,
Password = inputDto.Password,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
await InsertAsync(accountModel);
return(new RegisterOutputDto {
Passed = true, Message = "Rejestracja przebiegła poprawnie"
});
}
public async Task <IActionResult> Register(RegisterInputDto inputDto)
{
var password = _encryptService.DecryptRsa(inputDto.Password);
if (string.IsNullOrEmpty(password))
{
return(ObjectResponse.Error("密码格式不正确"));
}
if (Regex.IsMatch(password, RegexConstance.IsPassword) == false)
{
return(ObjectResponse.Error(password.Length < 6 ? "密码长度不能少于6个字符" : "密码长度不能超过20个字符"));
}
//验证验证码
var validResult = await _validationComponent.ValidSmsAsync(inputDto.Phone, inputDto.Code);
if (!validResult.Data)
{
return(ObjectResponse.Ok(validResult.Code, validResult.Message));
}
if (await _userService.ExistPhoneAsync(inputDto.Phone))
{
return(ObjectResponse.Error("手机号已存在"));
}
var userEntity = await _userService.RegisterAsync(inputDto.Phone, password, _appSettings.ClientId, _appSettings.ClientName, HttpContext.GetIp(), inputDto.Nickname);
var openId = MD5.Compute($"openId{_appSettings.ClientId}{userEntity.Id}");
var registerOutput = _mapper.Map <RegisterOutputDto>(userEntity);
registerOutput.OpenId = openId;
return(ObjectResponse.Ok(registerOutput));
}
public async Task <IdentityResult> Register(RegisterInputDto model)
{
var user = new User
{
UserName = model.UserName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
Name = model.Name,
SurName = model.SurName,
Birthday = model.Birthday,
Photo = "\\User\\anonymous.jpeg"
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = await _userManager.AddToRoleAsync(user, "User");
if (user.Email.Contains("admin.com"))
{
result = await _userManager.AddToRoleAsync(user, "Admin");
}
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = $"{_client.Url}{_client.EmailConfirmationPath}?uid={user.Id}&code={System.Net.WebUtility.UrlEncode(code)}";
//if (!_environment.IsDevelopment())
//{
// await _emailService.SendEmailConfirmationAsync(model.Email, callbackUrl);
//}
}
return(result);
}
return(result);
}
public async Task Register(RegisterInputDto inputDto)
{
var exists = await _customerRepo.ExistAsync(t => t.Account == inputDto.Account);
if (exists)
{
throw new BusinessException(new ErrorModel(ErrorCode.Forbidden, "该账号已经存在"));
}
var customer = _mapper.Map <Customer>(inputDto);
customer.ID = new Snowflake(1, 1).NextId();
var customerFinace = new CusFinance()
{
Account = customer.Account
,
Balance = 0
,
ID = customer.ID
};
await _cusManagerService.Register(customer, customerFinace);
}
//[Permission("customerRegister")]
public async Task <SimpleDto <string> > Register([FromBody][NotNull] RegisterInputDto inputDto)
{
return(await _cusService.Register(inputDto));
}
//[Permission("customerRegister")]
public async Task Register([FromBody][NotNull] RegisterInputDto inputDto)
{
await _cusService.Register(inputDto);
}
