public double RegisterRetrieveEmission(RegisterInput input)
{
if (input.FuelType != null)
{
if (input.Kml != 0)
{
return(RetrieveEmission(input.Kml, input.FuelType));
}
else
{
return(RetrieveEmission(input.FuelType));
}
}
else
{
return(RetrieveEmission());
}
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
var user = await _userRegistrationManager.RegisterAsync(
input.Name,
input.Surname,
input.EmailAddress,
input.UserName,
input.Password,
false
);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
var user = await _userRegistrationManager.RegisterAsync(
input.Name,
input.Surname,
input.EmailAddress,
input.UserName,
input.Password,
true // Assumed email address is always confirmed. Change this if you want to implement email confirmation.
);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
public async Task <IActionResult> CreateAccount(RegisterInput registerInput)
{
var user = new ApplicationUser
{
UserName = registerInput.Username,
Email = registerInput.Email
};
var result = await _userManager.CreateAsync(user, registerInput.Password);
if (!result.Succeeded)
{
return(BadRequest());
}
else
{
SendAccountConfirmationEmail(user);
return(Ok());
}
}
public async Task <IActionResult> Register(RegisterInput input)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var isUserExits = await _userService.IsUserExists(input.UserName);
if (isUserExits)
{
return(BadRequest("UserName already exits"));
}
await _userService.Register(input);
return(Ok());
}
public async Task <IActionResult> Edit(RegisterInput model)
{
if (ModelState.IsValid)
{
var user = await _userRepository.GetUser(model.Email);
user.Name = model.Name;
string passwordHash = BCrypt.Net.BCrypt.HashPassword(model.Password);
user.Password = passwordHash;
await _userRepository.Update(user);
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task Execute(RegisterInput input)
{
var customer = _entityFactory.NewCustomer(input.SSN, input.Name);
var account = _entityFactory.NewAccount(customer);
var credit = account.Deposit(_entityFactory, input.InitialAmount);
customer.Register(account);
await _customerRepository.Add(customer);
await _accountRepository.Add(account, credit);
await _unitOfWork.Save();
var output = new RegisterOutput(customer, account);
_outputHandler.Standard(output);
}
public async Task <ActionResult> Register(RegisterInput input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var user = new User()
{
Email = input.Email, Name = input.Name, Password = input.Password
};
//user.HashPassword();
await _userTaskService.CreateUser(user);
Auth.Authenticate(user, ControllerContext.HttpContext.Response);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Register([FromBody] RegisterInput input)
{
var user = new User
{
Firstname = input.Firstname,
Lastname = input.Lastname,
Email = input.Email,
UserName = input.Email
};
var createdUser = await _userService.Create(user, input.Password);
if (!createdUser.Success)
{
return(BadRequest <List <string> >(createdUser.Errors, "Kayıt işleminiz tamamlanamadı. Lütfen girmiş olduğunuz bilgileri kontrol edin."));
}
var addedRole = await _userService.AddToRole(user, "User");
if (!addedRole.Success)
{
return(BadRequest <List <string> >(addedRole.Errors, "Kayıt işleminiz tamamlanamadı. Lütfen girmiş olduğunuz bilgileri kontrol edin."));
}
var createdToken = await _authenticationService.CreateToken(user);
if (!createdToken.Success)
{
return(BadRequest <List <string> >(createdToken.Errors, "Kayıt işleminiz başarıyla tamamlandı, ancak token oluşturulma sırasında bir hata oluştu."));
}
var data = new RegisterDto
{
UserId = user.Id,
Firstname = user.Firstname,
Lastname = user.Lastname,
Email = user.Email,
AccessToken = createdToken.Data
};
return(Success <RegisterDto>(data, "Kayıt işleminiz başarıyla tamamlandı."));
}
public async Task Execute(RegisterInput input)
{
ICustomer customer;
if (_userService.GetCustomerId() is CustomerId customerId)
{
try
{
customer = await _customerRepository.GetBy(customerId);
_outputPort.CustomerAlreadyRegistered($"Customer already exists.");
return;
}
catch (CustomerNotFoundException)
{
}
}
customer = _entityFactory.NewCustomer(input.SSN, _userService.GetUserName());
var account = _entityFactory.NewAccount(customer);
var credit = account.Deposit(
_entityFactory,
input.InitialAmount);
customer.Register(account);
var user = _entityFactory.NewUser(
customer,
_userService.GetExternalUserId());
await _customerRepository.Add(customer);
await _accountRepository.Add(account, credit);
await _userRepository.Add(user);
await _unitOfWork.Save();
BuildOutput(_userService.GetExternalUserId(), customer, account);
}
public ActionResult Register(RegisterInput input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var user = new User()
{
Email = input.Email, Name = input.Name, Password = input.Password
};
user.HashPassword();
Users.Store(user);
Auth.Authenticate(user, ControllerContext.HttpContext.Response);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Register([FromBody] RegisterInput account)
{
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = account.Email, Email = account.Email
};
var result = await _userManager.CreateAsync(user, account.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(account.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// await _signInManager.SignInAsync(user, isPersistent: false);
return(Ok(new
{
message = "Register Succeeded!"
}));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(BadRequest(new
{
message = ModelState.Values
}));
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
try
{
if (UseCaptchaOnRegistration())
{
await RecaptchaValidator.ValidateAsync(input.CaptchaResponse);
}
var user = await _userRegistrationManager.RegisterAsync(
input.Name,
input.Surname,
input.EmailAddress,
input.UserName,
input.Password,
false,
AppUrlService.CreateEmailActivationUrlFormat(AbpSession.TenantId),
input.ExperienceLevel
);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
catch (UserFriendlyException e)
{
return(new RegisterOutput
{
CanLogin = false,
Message = e.Message
});
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <Response <bool> > Register(RegisterInput input)
{
try
{
ValidateHelper.Begin()
.IsPasswordFomat(input.Password)
.IsEmail(input.Email);
_memberSerevice = new MemberSerevice();
var result = await _memberSerevice.Register(input);
return(result);
}
catch (Exception e)
{
return(new Response <bool>()
{
Success = false,
Message = e.Message,
});
}
}
public async Task Execute(RegisterInput input)
{
if (input == null)
{
_outputHandler.Error("Input is null.");
return;
}
var customer = _entityFactory.NewCustomer(input.SSN, input.Name);
var account = _entityFactory.NewAccount(customer);
ICredit credit = account.Deposit(_entityFactory, input.InitialAmount);
if (credit == null)
{
_outputHandler.Error("An error happened when depositing the amount.");
return;
}
customer.Register(account);
// Call to an external Web Api
await _customerRepository.Add(customer);
await _accountRepository.Add(account, credit);
// Publish the event to the enterprice service bus
await _serviceBus.PublishEventAsync(new RegistrationCompleted()
{
CustomerId = customer.Id, AccountId = account.Id, CreditId = credit.Id
});
await _unitOfWork.Save();
RegisterOutput output = new RegisterOutput(customer, account);
_outputHandler.Standard(output);
}
public async Task Register_And_TryAccess_Authorized_Endpoint_ShouldBeOk()
{
// Arrange
var request = new RestRequest("api/v1/Account/Register", Method.POST, DataFormat.Json);
var registerData = new RegisterInput
{
Email = "*****@*****.**",
Login = "******",
Password = "******",
UserName = "******"
};
request.AddJsonBody(registerData);
// Act
var response = await rest.ExecuteAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Contains("token", response.Content);
var users = _context.Users.ToList();
Assert.Single(users);
// Step 2
var obj = JsonConvert.DeserializeObject <AuthToken>(response.Content);
var request2 = new RestRequest($"api/v1/Folder/{obj.DiskInfo.FolderId}", Method.GET, DataFormat.Json);
request2.AddHeader("Authorization", $"Bearer {obj.Token}");
response = await rest.ExecuteAsync(request2);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var obj2 = JsonConvert.DeserializeObject <FolderContent>(response.Content);
Assert.Empty(obj2.Files);
Assert.Empty(obj2.Folders);
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
try
{
var user = await _userRegistrationManager.RegisterAsync(
input.FirstName,
input.LastName,
input.UserName,
input.YourName,
input.ContentType,
input.ContentVolume,
input.Industry,
input.IsContentShedule,
input.CMS,
input.Website,
input.Company,
input.UserType,
input.PhoneNumber,
input.EmailAddress,
input.Password,
false
);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
await SendEmailActivationLink(new SendEmailActivationLinkInput()
{
EmailAddress = input.EmailAddress
});
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
catch (Exception ex)
{
throw new UserFriendlyException(ex.Message);
}
}
public UserModel Register(RegisterInput input)
{
AceUtils.EnsureAccountNameLegal(input.AccountName);
PasswordHelper.EnsurePasswordLegal(input.Password);
if (input.NickName.IsNullOrEmpty() || input.NickName.Length < 2 || input.NickName.Length > 15)
{
throw new InvalidInputException("昵称太短或太长");
}
string accountName = input.AccountName.ToLower();
AceUtils.EnsureAccountNameLegal(accountName);
bool exists = this._userRepository.Query().Where(a => a.AccountName == accountName).Any();
if (exists)
{
throw new InvalidInputException("用户名[{0}]已存在".ToFormat(input.AccountName));
}
UserDetail user = new UserDetail();
user.AccountName = accountName;
user.NickName = input.NickName;
string userSecretkey = UserHelper.GenUserSecretkey();
string encryptedPassword = PasswordHelper.Encrypt(input.Password, userSecretkey);
user.SecretKey = userSecretkey;
user.Password = encryptedPassword;
user.HeadPhoto = "/content/images/avatar.png";
user.RegisterTime = DateTime.Now;
this._userRepository.AddUser(user);
return(UserModel.Create(user));
}
public async Task <ActionResult> Register([FromBody] RegisterInput input)
{
var user = await _authenticationAppService.FindUserByEmailAsync(input.Email);
if (user != null)
{
return(Conflict("Email already exist!")); // TODO: Make these messages static object
}
user = await _authenticationAppService.FindUserByUserNameAsync(input.Email);
if (user != null)
{
return(Conflict("User name already exist!")); // TODO: Make these messages static object
}
var applicationUser = new User
{
UserName = input.UserName,
Email = input.Email
};
var result = await _authenticationAppService.CreateUserAsync(applicationUser, input.Password);
if (!result.Succeeded)
{
return(BadRequest(string.Join(Environment.NewLine, result.Errors.Select(e => e.Description))));
}
var confirmationToken = await _authenticationAppService.GenerateEmailConfirmationTokenAsync(applicationUser);
var callbackUrl = $"{_configuration[AppConfig.App_ClientUrl]}/account/confirm-email?email={applicationUser.Email}&token={HttpUtility.UrlEncode(confirmationToken)}";
var subject = "Confirm your email.";
var message = $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>{callbackUrl}</a>";
//await _emailSender.SendEmailAsync(applicationUser.Email, subject, message);
return(Ok(new RegisterOutput {
ResetToken = confirmationToken
}));
}
/// <summary>
/// Executes the Use Case.
/// </summary>
/// <param name="input">Input Message.</param>
/// <returns>Task.</returns>
public async Task Execute(RegisterInput input)
{
if (input is null)
{
this._registerOutputPort
.WriteError(Messages.InputIsNull);
return;
}
IUser user = this._userService
.GetUser();
if (await this.VerifyCustomerAlreadyRegistered(user)
.ConfigureAwait(false))
{
return;
}
ICustomer customer = await this._customerService
.CreateCustomer(input.SSN, user.Name)
.ConfigureAwait(false);
IAccount account = await this._accountService
.OpenCheckingAccount(customer.Id, input.InitialAmount)
.ConfigureAwait(false);
await this._securityService
.CreateUserCredentials(user, customer.Id)
.ConfigureAwait(false);
customer.Assign(account.Id);
await this._unitOfWork.Save()
.ConfigureAwait(false);
this.BuildOutput(user, customer, new List <IAccount> {
account
});
}
public DailyRoutine.Core.Authorization.User.User SingUp(RegisterInput input)
{
var context = new DailyRoutineDbContext();
if (context.Users.Where(x => x.UserName == input.UserName).Count() > 0)
{
return(null);
}
else
{
var user = new DailyRoutine.Core.Authorization.User.User();
user.EmailAddress = input.EmailAddress;
user.UserName = input.UserName;
user.Password = input.Password;
user.Name = input.Name;
user.Surname = input.Surname;
user.PhoneNumber = input.PhoneNumber;
var addedUser = context.Users.Add(user);
context.SaveChanges();
return(addedUser.Entity);
}
}
public void Post([FromBody] RegisterInput value)
{
User userTest = repository.FindByUserName(value.Username);
if (userTest.Username == value.Username)
{
throw new UnauthorizedAccessException();
}
else
{
User novy = new User();
novy.Username = value.Username;
novy.Password = value.Password;
novy.Email = value.Email;
novy.ProfileImage = value.ProfileImage;
novy.Token = value.Token;
novy.Id = ++IDe;
this.repository.Create(novy);
}
}
internal async Task <int> EmployeeRegisterAsync(GrpcChannel channel,
string firstName,
string lastName,
string email,
string hashedPassword,
PermissionsEnum permission,
int directManager)
{
var client = new Users.UsersClient(channel);
var input = new RegisterInput
{
FirstName = firstName,
LastName = lastName,
Email = email,
Password = hashedPassword,
Permission = permission.ToString(),
DirectManager = directManager
};
var result = await client.RegisterAsync(input);
return(result.Value);
}
private async Task RegisterUserAsync()
{
var results = DataAnnotationsValidator.Validate(this);
if (results.IsValid)
{
await SetBusyAsync(async() =>
{
if (!string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password) && ExperienceLevel != null)
{
var registerInput = new RegisterInput
{
UserName = Username.Trim(),
EmailAddress = Email.Trim(),
Password = Password,
Name = Username.Trim(),
Surname = Username.Trim(),
ExperienceLevel = ExperienceLevel.Value
};
var result = await _accountAppService.Register(registerInput);
if (result.CanLogin)
{
await UserDialogs.Instance.AlertAsync(result.Message, "RegistrationSuccess".Translate());
await SetLoginPage();
}
else
{
await UserDialogs.Instance.AlertAsync(result.Message, "RegistrationError".Translate());
}
}
}, "RegisterUser".Translate());
}
else
{
UserDialogHelper.Error(results.ConsolidatedMessage);
}
}
public async Task <ActionResult> Register(RegisterInput input)
{
if (ModelState.IsValid)
{
var user = new User
{
FirstName = input.FirstName,
LastName = input.LastName,
UserName = input.Email,
Email = input.Email,
Picture = input.Picture
};
var result = await userManager.CreateAsync(user, input.Password);
if (result.Succeeded)
{
return(Ok(new JsonResult("Successful")));
}
}
return(BadRequest());
}
public async Task <ApplicationBaseResult> Register(RegisterInput input)
{
return(await DoAsync(async (x) =>
{
await Task.Delay(0);
if (string.IsNullOrEmpty(input.UserName))
{
x.Code = -1;
x.Message = "请输入用户名";
}
if (UserNames.Any(y => y.Equals(input.UserName)))
{
x.Code = -1;
x.Message = "该用户注册过了";
}
else
{
UserNames.Add(input.UserName);
x.Code = 0;
x.Message = "注册成功";
}
}));
}
public async Task Execute(RegisterInput input)
{
if (_userService.GetCustomerId() is CustomerId customerId)
{
if (await _customerService.IsCustomerRegistered(customerId))
{
_outputPort.CustomerAlreadyRegistered($"Customer already exists.");
return;
}
}
var customer = await _customerService.CreateCustomer(input.SSN, _userService.GetUserName());
var account = await _accountService.OpenCheckingAccount(customer.Id, input.InitialAmount);
var user = await _securityService.CreateUserCredentials(customer.Id, _userService.GetExternalUserId());
customer.Register(account.Id);
await _unitOfWork.Save();
BuildOutput(_userService.GetExternalUserId(), customer, account);
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
string code = _cacheManager.GetCache("chageCode").GetOrDefault <string, string>(input.PhoneNumber);
if (input.VerificationCode == code)
{
if (UseCaptchaOnRegistration())
{
await RecaptchaValidator.ValidateAsync(input.CaptchaResponse);
}
var user = await _userRegistrationManager.RegisterAsync(
input.Name,
input.Surname,
input.EmailAddress,
input.UserName,
input.Password,
false,
AppUrlService.CreateEmailActivationUrlFormat(AbpSession.TenantId)
);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
else
{
return(new RegisterOutput
{
CanLogin = false,
ErroMsg = "验证码错误"
});
}
}
public async Task <ActionResult> Register([FromBody] RegisterInput input)
{
var user = await _userManager.FindByEmailAsync(input.Email);
if (user != null)
{
return(BadRequest(new List <NameValueDto>
{
new NameValueDto("EmailAlreadyExist", "This email already exists!")
}));
}
var applicationUser = new User
{
UserName = input.Login,
Email = input.Email,
EmailConfirmed = true,
FirstName = input.FirstName,
LastName = input.LastName,
DeansOfficeId = input.DeansOfficeId
};
var result = await _userManager.CreateAsync(applicationUser, input.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.Select(e => new NameValueDto(e.Code, e.Description)).ToList()));
}
else
{
_userAppService.GrantRolesToUser(new List <Guid> {
DefaultRoles.Student.Id
}, applicationUser);
}
return(Ok());
}
public async Task <RegisterOutput> Register(RegisterInput input)
{
var user = await _userRegistrationManager.RegisterAsync(
input.Name,
input.Surname,
input.EmailAddress,
input.UserName,
input.Password,
true, // Assumed email address is always confirmed. Change this if you want to implement email confirmation.
(int)UserTypeEnum.AGENT
);
int count = (await _agentsRepository.GetAllListAsync()).Count;
int maxPMcode = 0;
if (count > 0)
{
maxPMcode = (await _agentsRepository.GetAllListAsync()).Max(x => x.PMCode);
}
Agents.Agents agentBankInfo = new Agents.Agents
{
AccountName = input.AccountName,
AccountNumber = input.AccountNumber,
BankName = input.BankName,
UserId = user.Id,
PMCode = ++maxPMcode
};
await _agentsRepository.InsertAsync(agentBankInfo);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
return(new RegisterOutput
{
CanLogin = user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)
});
}
public RegisterModel Register(RegisterInput input)
{
return _request.Has<RegisterModel>() ? _request.Get<RegisterModel>() : new RegisterModel();
}
