public ActionResult <string> Register([FromBody] RegisterRequestModel registerRequestModel)
{
if (_databaseService.Users.FirstOrDefault(t => t.Username == registerRequestModel.Username) != null)
{
throw new UsernameDuplicatedException("Username duplicated.");
}
// 创建用户
User user = new User();
user.Username = registerRequestModel.Username;
user.Password = BCrypt.Net.BCrypt.HashPassword(registerRequestModel.Password);
user.Nickname = registerRequestModel.Nickname;
user.Status = 0;
_databaseService.Users.Add(user);
_databaseService.SaveChanges();
// 创建用户组信息
GroupToUser groupToUser = new GroupToUser()
{
GroupId = Group.GroupID.DEFAULT,
UserId = user.Id
};
_databaseService.GroupsToUsersRelation.Add(groupToUser);
// 创建用户目录
var groupDirectory = EntityFile.CreateDirectoryRecord(user.Username, "/users", $"/users/{user.Username}", user);
_databaseService.Files.Add(groupDirectory);
_databaseService.SaveChanges();
return(Ok(new RegisterResultModel(user)));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel requestModel)
{
//check allowed
var existing = _userManager.Users.SingleOrDefault(x => x.Email == requestModel.Email);
if (existing != null)
{
throw new UserMessageException("Username is already taken");
}
var user = new User(requestModel.Email, requestModel.Email)
{
Created = DateTime.UtcNow
};
IdentityResult createUserResult = await _userManager.CreateAsync(user, requestModel.Password);
await _userManager.AddToRoleAsync(user, requestModel.Role.ToString());
if (!createUserResult.Succeeded)
{
throw new UserMessageException(createUserResult.Errors.First().Description);
}
return(Ok());
}
public async Task <ActionResult <RegisterResponseModel> > IndexPost([FromBody] RegisterRequestModel request)
{
var trimmedUsername = request.Username.Trim();
if (request.Password != request.PasswordConfirm)
{
return(BadRequest(new RegisterResponseModel("Passwords do not match")));
}
if (request.Password.Length < 8)
{
return(BadRequest(new RegisterResponseModel("Password must be at least 8 characters")));
}
if (await database.Users.AnyAsync(u => u.Name == trimmedUsername))
{
return(BadRequest(new RegisterResponseModel("Username already taken")));
}
var salt = crypto.RandomSalt();
var user = new User
{
Name = trimmedUsername,
PasswordHash = crypto.Hash(request.Password, salt),
PasswordSalt = salt,
JoinDate = DateTime.Now
};
database.Users.Add(user);
await database.SaveChangesAsync();
return(new RegisterResponseModel("ok"));
}
/// <summary>
/// Admins the register asynchronous.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public async Task <bool> AdminRegisterAsync(RegisterRequestModel model)
{
try
{
SqlConnection connection = DBConnection();
string encrypted = EncryptPassword(model.Password);
SqlCommand command = StoreProcedureConnection("spRegisterAdmin", connection);
command.Parameters.AddWithValue("FirstName", model.FirstName);
command.Parameters.AddWithValue("LastName", model.LastName);
command.Parameters.AddWithValue("PhoneNumber", model.PhoneNumber);
command.Parameters.AddWithValue("Email", model.Email);
command.Parameters.AddWithValue("Password", encrypted);
command.Parameters.AddWithValue("UserAddress", model.UserAddress);
command.Parameters.AddWithValue("ServiceType", model.ServiceType);
connection.Open();
int result = await command.ExecuteNonQueryAsync();
connection.Close();
if (result != 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult> Register(RegisterRequestModel model)
{
var roles = new SelectList(new List <string>()
{
Roles.StudentRole, Roles.AdminRole, Roles.TeacherRole
});
model.Roles = roles;
if (ModelState.IsValid)
{
var user = new User
{
UserName = model.Username,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
StudentNumber = model.StudentNumber
};
await this.userManager.CreateAsync(user, "12345678");
await this.userManager.AddToRoleAsync(user, model.Role);
return(RedirectToAction("Index", "Users"));
}
return(View(model));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model)
{
if (await _authService.UserAlreadyExistsAsync(model.Email))
{
return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponseModel {
Status = "Error", Message = "Email already exists in the database. Please use an unique email for registration, or contact one of our administrator to recover your password/account."
}));
}
ApplicationUser user = new ApplicationUser()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.Email,
};
var result = await _authService.CreateUserAsync(user, model.Password);
if (!result.Succeeded)
{
var errorList = result.Errors.Select(e => e.Description);
return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponseModel {
Status = "Error", Message = "User creation failed. Please check user details and try again.", Errors = errorList
}));
}
return(Ok(new BaseResponseModel {
Status = "Success", Message = "User created successfully."
}));
}
public IHttpActionResult Register(RegisterRequestModel requestModel)
{
if (ModelState.IsValid)
{
UsernameCommand uniqueUsernameCommand = new UsernameCommand(requestModel.Username);
IEnumerable <ValidationResult> validations = commandDispatcher.Validate(uniqueUsernameCommand);
ModelState.AddModelErrors(validations);
if (ModelState.IsValid)
{
AccountCommand accountCommand = new AccountCommand(requestModel.Username, requestModel.Password);
Account account = commandDispatcher.Dispatch <AccountCommand, Account>(accountCommand);
AuthCommand authCommand = new AuthCommand(account.Id, false);
Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(authCommand);
AccountResponseModel responseModel = Mapper
.Map <AccountResponseModel>(authentication)
.Map(account);
return(Ok(responseModel));
}
}
return(BadRequest(ModelState));
}
public RegisterViewModel()
{
RegistrationCommand = new RelayCommand <object>(Register);
ImportImageCommand = new RelayCommand <object>(ImportImage);
RegisterRequestModel = new RegisterRequestModel();
IsLoading = false;
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model)
{
try
{
var user = await _accountService.CreateAsync(new ()
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
Password = model.Password
});
// TODO: Send confirm email mail
return(Ok());
}
catch (UserAlreadyExistsException)
{
return(BadRequest(new ErrorViewModel()
{
ErrorKey = "user_already_exists"
}));
}
catch (UserCreateException)
{
return(BadRequest(new ErrorViewModel()
{
ErrorKey = "user_could_not_be_created"
}));
}
catch (Exception)
{
return(StatusCode(500, ErrorViewModel.UNHANDLED_EXCEPTION));
}
}
public IHttpActionResult Register(RegisterRequestModel data)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ItemResponse <string> response = new ItemResponse <string>();
string guid = _userService.Register(data);
if (guid == "1")
{
response.Item = "Sorry, that UserName is already taken!";
}
else if (guid == "0")
{
response.Item = "An account with that email already exists!";
}
else
{
response.Item = "0";
}
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ApiBaseResponse> RegisterAsync(RegisterRequestModel requestModel)
{
ApiBaseResponse apiBaseResponse = new ApiBaseResponse();
var isExistedEmail = await _userService.ExistedByEmailAsync(requestModel.Email);
if (isExistedEmail)
{
throw new BlogSolutionException("The email address has already exist.", ApplicationStatusCode.AnErrorHasOccured);
}
var isExistedUsername = await _userService.ExistedByUsernameAsync(requestModel.Username);
if (isExistedUsername)
{
throw new BlogSolutionException("The username has already exist.", ApplicationStatusCode.AnErrorHasOccured);
}
var password = new PasswordHasher(requestModel.Password);
await _userService.AddUserAsync(new User
{
Username = requestModel.Username,
Name = requestModel.Name,
Email = requestModel.Email,
PhoneNumber = requestModel.PhoneNumber,
PasswordHash = password.Hash,
PasswordSalt = password.Salt
});
return(apiBaseResponse);
}
public async Task <IActionResult> RegisterAsync(RegisterRequestModel model)
{
try
{
if (model != null)
{
if (await account.RegisterAsync(model))
{
return(Ok(new { Success = true, Message = "User is Registered SuccessFully", model }));
}
else
{
return(BadRequest(new { Success = false, Message = "User is not Registered", model }));
}
}
else
{
return(BadRequest(new { Success = false, Message = "Insufficients details....", model }));
}
}
catch (Exception e)
{
return(BadRequest(new { Success = false, Message = e.Message }));
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model)
{
var userExists = await userManager.FindByNameAsync(model.Username);
if (userExists != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponse {
Status = "Error", Message = "User already exists!"
}));
}
User user = new User()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.Username
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponse {
Status = "Error", Message = "User creation failed! Please check user details and try again."
}));
}
return(Ok(new BaseResponse {
Status = "Success", Message = "User created successfully!"
}));
}
public async Task <AuthenticationResponseModel> RegisterAsync(RegisterRequestModel registerRequest)
{
if (registerRequest == null)
{
throw new TracketBadRequestException(_localizer[Constants.LocalizedValueKeys.Messages.PleaseProvideRequiredInformationMessage]);
}
//IdentityRole findRole = await _roleManager.FindByNameAsync(registerRequest.RoleName);
//if (findRole == null)
//{
// throw new TracketNotFoundException(_localizer[Constants.LocalizeKeys.RoleNotFound]);
//}
using (var transaction = _unitOfWork.DBContext.Database.BeginTransaction())
{
TracketUser identityUser = new TracketUser
{
Email = registerRequest.Email,
UserName = "******"
};
}
return(null);
}
public async Task <(AccountResponseModel, bool)> Update(RegisterRequestModel registerRequest)
{
// attempt to sign in
var result = await _signInManager.PasswordSignInAsync(registerRequest.Email, registerRequest.Password, false, false);
// return false if sign in fails
if (!result.Succeeded)
{
return(null, false);
}
// if login succeeded, return updated user
var logged = await _userManager.FindByEmailAsync(registerRequest.Email);
logged.Email = registerRequest.Email;
logged.UserName = registerRequest.Email;
logged.Name = registerRequest.Name;
var updated = await _userManager.UpdateAsync(logged);
// return false if update fails
if (!updated.Succeeded)
{
return(null, false);
}
var claims = await _userManager.GetClaimsAsync(logged);
return(ToResponseModel(logged, claims), true);
}
/// <summary>
/// Edit action method to redirect from index page to update page
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ActionResult Edit(RegisterRequestModel model)
{
RegisterRequestModel emp = employeeRepository.GetEmployee(model.EmpId);
ModelState.Clear();
return(View("RegisterEmployee", emp));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model)
{
var userExist = await _userManager.FindByNameAsync(model.UserName);
if (userExist != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Erro", Message = "Usuário já existe"
}));
}
User user = new User()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.UserName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Erro", Message = "Ops, ocorreu um erro no sistema"
}));
}
return(Ok(new Response {
Status = "Sucesso", Message = "Usuário criado com sucesso"
}));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel credentials)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = credentials.Name, Email = credentials.Email
};
var result = await _userManager.CreateAsync(user, credentials.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(new JsonResult(new Dictionary <string, object>
{
{ "access_token", GetAccessToken(credentials.Name) },
{ "id_token", GetIdToken(user) },
{ "name", user.UserName },
{ "id", user.Id }
}));
}
return(Errors(result));
}
return(Error("Unexpected error"));
}
public bool RegisterEmployee(RegisterRequestModel employee)
{
try
{
Employee validEmployee = dbContext.Employees.Where(x => x.name == employee.name && x.gender == employee.gender).FirstOrDefault();
if (validEmployee == null)
{
int departmentId = dbContext.Departments.Where(x => x.deptname == employee.department).Select(x => x.deptid).FirstOrDefault();
Employee newEmployee = new Employee()
{
name = employee.name,
gender = employee.gender,
deptid = departmentId,
salaryid = Convert.ToInt32(employee.salaryid),
startdate = employee.startdate,
description = employee.description
};
Employee returnData = dbContext.Employees.Add(newEmployee);
}
int result = dbContext.SaveChanges();
if (result > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <ResponseViewModel> Create([FromBody] RegisterRequestModel model)
{
var oldOperator = await _accountService.GetByUsername(model.Username);
if (oldOperator != null)
{
var response = new ResponseViewModel
{
Result = false,
};
response.Messages.Add("Email đã tồn tại");
return(response);
}
else
{
var account = new Account
{
Username = model.Email,
FullName = model.Fullname,
Email = model.Email,
Phone = model.Phone,
Address = model.Address,
DateOfBirth = model.DateOfBirth,
AccountTypeId = 3,
AccountStatusId = 1,
Password = Encryptor.MD5Hash(model.Password),
};
ApplyUserCreateEntity(account);
return(await Save(account));
}
}
public IActionResult PostUser([FromBody] RegisterRequestModel user)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Users.Add(new WPAssign.Models.User()
{
EmailId = user.EmailId,
Name = user.Name,
Id = Guid.NewGuid().ToString(),
Password = user.Password,
PhoneNumber = user.PhoneNumber,
Username = user.Username,
Tickets = new List <Ticket>()
});
_context.SaveChanges();
return(Ok(new { Message = "Ok" }));
}
catch (Exception)
{
throw;
}
}
public HttpResponseMessage Registration(RegisterRequestModel user)
{
try
{
this.userManager.Registration(new UserDto
{
Login = user.Login,
Name = user.Name,
SurName = user.SurName,
MiddleName = user.MiddleName,
Email = user.Email,
Password = user.Password,
ConfirmPassword = user.ConfirmPassword,
Group = user.Group,
FacultyID = user.FacultyID,
KeyWord = user.KeyWord
}, "Admin");
this.userManager.SignIn(new UserDto
{
Login = user.Login,
Password = user.Password,
RememberMe = false
}, true);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (ArgumentException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, ex.Message));
}
}
public async Task <ActionResult <RegisterResponseModel> > RegisterAsync(RegisterRequestModel request)
{
var response = new RegisterResponseModel();
var user = await this.userService
.GetUserByRegistrationCodeAsync(request.RegistrationCode);
if (Object.Equals(user, null))
{
response.Status = -1;
response.Message = "Invalid Registration Code.";
return(Ok(response));
}
if (user.IsActivatedCode)
{
response.Status = -2;
response.Message = "The Registration Code Is Taken.";
return(Ok(response));
}
var hashedPassword = PasswordHasher
.HashPassword(request.Password);
await this.userService
.UpdateUserToRegistered(user.Id, request.Username, hashedPassword, request.Email);
response.Status = 1;
response.Message = "Success.";
return(Ok(response));
}
public virtual async Task <AuthResponse> Register(RegisterRequestModel model, CancellationToken cancellationToken = default(CancellationToken))
{
HttpResponseMessage httpResponse = await this.Client.PostAsJsonAsync($"api/auth/register", model, cancellationToken).ConfigureAwait(false);
this.HandleResponseCode(httpResponse);
return(JsonConvert.DeserializeObject <AuthResponse>(httpResponse.Content.ContentToString()));
}
public async Task <IActionResult> AdminRegistration(RegisterRequestModel register)
{
try
{
if (register != null)
{
if (await account.AdminRegisterAsync(register))
{
return(Ok(new { Success = true, Message = "Admin is Registered SuccessFully", register }));
}
else
{
return(BadRequest(new { Success = false, Message = "Admin is not Registered", register }));
}
}
else
{
return(BadRequest(new { Success = false, Message = "Insufficients details....", register }));
}
}
catch (Exception e)
{
return(BadRequest(new { Success = false, Message = e.Message }));
}
}
public async Task <ActionResult <LoginResponseModel> > Register([FromBody] RegisterRequestModel model)
{
var user = new User
{
Email = model.Email,
UserName = model.UserName,
};
var result = await this.userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(this.BadRequest(result.Errors));
}
var token = this.identityService.GenerateJwtToken(
user.Id,
user.UserName,
this.appSettings.Secret);
return(new LoginResponseModel
{
Token = token,
UserName = user.UserName,
Id = user.Id
});
}
public async Task <ActionResult> Register(RegisterRequestModel model)
{
IdentityResult result = new IdentityResult();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName
};
result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
ProfileDetailsModel profile = new ProfileDetailsModel
{
UserID = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
return(Json(new { Success = true, User = profile }));
}
}
return(Json(new { Success = false, Message = result.Errors }));
}
public bool RegisterEmployee(RegisterRequestModel employee)
{
try
{
Employee validEmployee = dbContext.Employees.Where(x => x.Name == employee.Name && x.Gender == employee.Gender).FirstOrDefault();
if (validEmployee == null)
{
int departmentId = dbContext.Departments.Where(x => x.DeptName == employee.Department).Select(x => x.DeptId).FirstOrDefault();
Employee newEmployee = new Employee()
{
Name = employee.Name,
Gender = employee.Gender,
DepartmentId = departmentId,
SalaryId = Convert.ToInt32(employee.Salary),
StartDate = employee.StartDate,
Description = employee.Description
};
Employee returnData = dbContext.Employees.Add(newEmployee);
}
int result = dbContext.SaveChanges();
if (result > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
return(false);
}
}
public async Task <IActionResult> Post([FromBody] RegisterRequestModel model)
{
model.RoleName = "GooiosVip0";
if (ModelState.IsValid)
{
//check the verification code
var verification = await _verificationProxy.GetVerification(BizCode.Register, model.Mobile);
if (verification == null)
{
return(new BadRequestObjectResult("验证码不正确."));
}
if (verification.Code != model.VerificationCode)
{
return(new BadRequestObjectResult("验证码不正确."));
}
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return(new BadRequestObjectResult("找不到指定角色."));
}
var user = new ApplicationUser {
UserName = model.Mobile, PhoneNumber = model.Mobile
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _verificationProxy.SetVerificationUsed(verification);
var r = await _userManager.AddToRoleAsync(user, model.RoleName);
return(new OkResult());
}
else
{
return(new BadRequestObjectResult("创建用户失败."));
}
}
else
{
var errors = ModelState.Values.Select(o => o.Errors);
var messageBuilder = new StringBuilder();
foreach (var error in errors)
{
string errMsg = string.Join(",", error.Select(o => o.ErrorMessage));
messageBuilder.Append(errMsg);
messageBuilder.Append(";");
}
return(new BadRequestObjectResult($"参数错误: {messageBuilder.ToString()}"));
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model)
{
var response = await accountService.Register(model);
if (response != null)
{
return(Ok(response));
}
return(NotFound("Prisiregistruoti nepavyko"));
}
