public async Task <IActionResult> Register([FromBody] RegisterResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = CreateNewUser(resource);
var result = await userManager.CreateAsync(user, resource.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, resource.Role);
CreateAccount(resource.Role, user.Id);
await unitOfWork.CompleteAsync();
//await userManager.AddToRoleAsync(user, adminRole.Name);
// var student = new IdentityRole("Student");
// await roleManager.CreateAsync(student);
// await roleManager.AddClaimAsync(student, new Claim("student", "true"));
// Add to role
// await userManager.AddToRoleAsync(user, "Customer");
}
return(Ok(new { Id = user.Id, Username = user.UserName }));
}
public async Task <IActionResult> Register(RegisterResource model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new ApplicationUser
{
UserName = model.UserName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
await _userManager.AddToRoleAsync(user, "Admin");
return(Ok());
}
AddErrors(result);
}
catch (Exception e)
{
return(BadRequest("Somwthing Gone Wrong"));
}
return(BadRequest());
}
public async Task <IActionResult> RegisterUser([FromForm] RegisterResource resource)
{
var login = await _userRepository.GetUserByLoginAsync(resource.Login);
if (login != null)
{
return(BadRequest($"Login {resource.Login} already exists"));
}
var email = await _userRepository.GetUserByEmailAsync(resource.Email);
if (email != null)
{
return(BadRequest($"Email {resource.Email} already exists"));
}
var hash = _hashService.HashPassword(resource.Password);
var register = await _registerUserService.RegisterUser(resource, hash);
if (register)
{
return(Ok("Account has been created"));
}
return(BadRequest("There was an unexpected error while creating account"));
}
public async Task <IActionResult> setRegStudent(RegisterResource register)
{
var res = await ITeacher.getStudent(register.id);
res.IsReg = register.isReg;
int x = updateDetails();
#warning Add track on who registered student TeacherController=>serRegStudent()
//============notification=============
var noti = new StudentNotification();
noti.StudentId = register.id;
noti.OtherId = register.otherId;
noti.OtherType = "T";
noti.Viwed = false;
noti.NotiDate = DateTime.Now.ToString();
if (register.isReg == true)
{
noti.NotiMessage = "You have been registered";
}
else
{
noti.NotiMessage = "You have been un-registered";
}
ITeacher.AdderAsync(noti);
ITeacher.Saver();
return(Ok(x));
}
public async Task <IActionResult> PasswordChange(RegisterResource resource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userId = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value;
var user = _userManager.Users.FirstOrDefault(x => x.Id == userId);
var result = await _userManager.ChangePasswordAsync(user, resource.Password, resource.ConfirmPassword);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task <object> Register([FromBody] User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newUser = new User {
UserName = user.UserName, Email = user.Email
};
var result = await _userManager.CreateAsync(newUser, user.PasswordHash);
if (result.Succeeded)
{
// await _signInManager.SignInAsync(newUser, false);
var registerResource = new RegisterResource
{
Token = _jwtTokenGenerator.GenerateJwtToken(user.UserName, newUser)
};
return(registerResource);
}
foreach (var responseError in result.Errors)
{
ModelState.AddModelError("errors", responseError.Description);
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Register([FromBody] RegisterResource model)
{
// Validate input fields
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Mapping the input to model class
var currentUser = _mapper.Map <RegisterResource, ApplicationUser>(model);
// In this application, UserName itseft is Email
currentUser.UserName = model.Email;
// Create a new User by User's info and password
var createResult = await _userManager.CreateAsync(currentUser, model.Password);
// Add roles to the User
var roleResult = await _userManager.AddToRoleAsync(currentUser, ApplicationConstants.RoleName.User);
var claimResult = await _userManager.AddClaimAsync(currentUser, new Claim(ApplicationConstants.ClaimName.User, "true"));
// Add claims as well
// Everything is fine, return 200 and log
if (createResult.Succeeded && roleResult.Succeeded && claimResult.Succeeded)
{
_logger.LogInformation(LoggingEvents.Success, "User with email " + model.Email + " created");
return(Ok());
}
// Failed at some point, return 400 and the errors
return(BadRequest(createResult));
}
public async Task <IActionResult> Register([FromBody] RegisterResource registerResource)
{
var result = await _authService.RegisterAsync(registerResource);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage));
}
return(Ok(result.Data));
}
public async Task <IActionResult> Register([FromBody] RegisterResource registerResource)
{
var user = _mapper.Map <ApplicationUser>(registerResource);
var result = await _authService.RegisterAsync(user, registerResource.Password);
if (!result.Succeeded)
{
return(BadRequest(_response.Error(result.Message)));
}
return(Ok(_response.Ok(result.Message)));
}
public IActionResult CreateUser([FromBody] RegisterResource register)
{
var user = _mapper.Map <User>(register);
try
{
_userService.Create(user, register.password);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public virtual async Task <IActionResult> Register([FromBody] RegisterResource registerResource)
{
var register = this.Mapper.Map <Register>(registerResource);
var result = await this.authService.Register(register);
var resultResource = this.Mapper.Map <RegisterResultResource>(result);
if (resultResource.Errors.Any())
{
return(this.BadRequest(resultResource.Errors));
}
return(this.Ok(resultResource.User));
}
public async Task <Player> Register([FromBody] RegisterResource regsiter)
{
var player = await _service.RegisterPlayer(
regsiter.Fullname,
regsiter.Email,
regsiter.Phone,
regsiter.Age,
regsiter.Gender,
regsiter.Username,
regsiter.Password
);
return(player);
}
public async Task <IActionResult> Register(RegisterResource resource)
{
if (await repo.FirstOrDefault(u =>
u.Email == resource.Email || u.Name == resource.Name) != null)
{
return(BadRequest("User with that email or name already exists"));
}
var user = mapper.Map <User>(resource);
var registeredUser = await authService.Register(user, resource.Password);
var userToReturn = mapper.Map <UserResource>(registeredUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = registeredUser.Id },
userToReturn));
}
public async Task <bool> RegisterUser(RegisterResource registerResource, string hashPassword)
{
User user = new User()
{
Email = registerResource.Email,
IsActive = true,
Login = registerResource.Login,
Name = registerResource.Name,
Surname = registerResource.Surname,
Password = hashPassword
};
await _userRepository.AddUser(user);
return(true);
}
public async Task <ActionResult> Register([FromBody] RegisterResource register)
{
if (_context.Users.Any(x => x.Email == register.Email))
{
return(Conflict(new
{
message = "This Email alredy exists"
}));
}
var user = _mapper.Map <RegisterResource, User>(register);
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(Ok(user));
}
private AppUser CreateNewUser(RegisterResource resource)
{
var contact = new Contact
{
FirstName = resource.FirstName,
FatherName = resource.FatherName,
GrandFatherName = resource.GrandFatherName,
DepartmentId = resource.DepartmentId,
};
return(new AppUser
{
Contact = contact,
Email = resource.Email,
UserName = resource.Email,
SecurityStamp = Guid.NewGuid().ToString()
});
}
public async Task <GenericResponse <StatusResponse> > RegisterAsync(RegisterResource registerResource)
{
var user = await _userManager.FindByEmailAsync(registerResource.Email);
if (user != null)
{
return new GenericResponse <StatusResponse>
{
Succeeded = false,
ErrorMessage = "The user account already exist!"
}
}
;
user = new ApplicationUser
{
FirstName = registerResource.FirstName,
LastName = registerResource.LastName,
PhoneNumber = registerResource.PhoneNumber,
Email = registerResource.Email,
UserName = registerResource.Email,
};
var result = await _userManager.CreateAsync(user, registerResource.Password);
if (!result.Succeeded)
{
return new GenericResponse <StatusResponse>
{
Succeeded = false,
ErrorMessage = string.Join(", ", result.Errors.Select(x => x.Description))
}
}
;
await SendEmailConfirmationLink(user);
return(new GenericResponse <StatusResponse>
{
Succeeded = true,
Data = new StatusResponse {
Status = $"Registration Successful, check your {user.Email} for link to confirm your email"
}
});
}
public async Task <IActionResult> Register(RegisterResource model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new ApplicationUser
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
DateCreated = DateTime.Now,
UserName = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var userInDb = GetUser(user.Email);
// await _signInManager.SignInAsync(user, false);
var authData = new AuthDataResource
{
Token = await GenerateJwtToken(userInDb),
UserId = userInDb.Id,
ExpireTime = DateTime.Now.AddHours(Convert.ToDouble(_configuration["JwtExpireHours"])),
FirstName = userInDb.FirstName,
LastName = userInDb.LastName
};
return(Ok(authData));
}
AddErrors(result);
}
catch (Exception e)
{
return(BadRequest("Somwthing Gone Wrong"));
}
return(BadRequest());
}
public async Task<IActionResult> Register([FromBody]RegisterResource registerResource)
{
if (!ModelState.IsValid)
return BadRequest(ModelState);
var emailExist = await _userManager.FindByEmailAsync(registerResource.Email);
if (emailExist != null)
return BadRequest("Email already in use.");
var user = new ApplicationUser
{
UserName = registerResource.Email,
Email = registerResource.Email,
FirstName = registerResource.FirstName,
LastName = registerResource.LastName,
Country = registerResource.Country,
Address = registerResource.Address,
State = registerResource.State,
PhoneNumber = registerResource.PhoneNumber
};
var result = await _userManager.CreateAsync(user, registerResource.Password);
if (result.Succeeded)
{
var roleAddresult = await _userManager.AddToRoleAsync(user, "Passenger");
if (roleAddresult.Succeeded)
{
return Ok(user);
}
return BadRequest("User created successfully but Role can not be created. Errors are: " + roleAddresult.Errors.ToString());
}
var sb = new StringBuilder();
foreach (var error in result.Errors)
{
sb.Append(error.Description);
sb.Append("\n");
}
return BadRequest(sb.ToString());
}
public async Task <IActionResult> SignUp([FromBody] RegisterResource credentials)
{
if (ModelState.IsValid)
{
var user = new User()
{
UserName = credentials.Username,
Email = credentials.Email
};
var result = await _userManager.CreateAsync(user, credentials.Password);
if (result.Succeeded)
{
return(Ok(await GetTokenResponse(user.UserName, true)));
}
return(BadRequest(new ApiResponse(result)));
}
return(BadRequest(new ApiResponse(ModelState)));
}
public async Task <string> RegisterAsync(RegisterResource registerResource)
{
var user = await _userManager.FindByEmailAsync(registerResource.Email);
if (user != null)
{
return("The user account already exist!");
}
if (!await _roleManager.RoleExistsAsync(registerResource.Role))
{
return("The role does not exist!");
}
user = new AppUser
{
FirstName = registerResource.FirstName,
LastName = registerResource.LastName,
Email = registerResource.Email,
UserName = registerResource.Email
};
var result = await _userManager.CreateAsync(user, registerResource.Password);
if (!result.Succeeded)
{
return(string.Join(" ", result.Errors.Select(x => x.Description)));
}
result = await _userManager.AddToRoleAsync(user, registerResource.Role);
if (!result.Succeeded)
{
return(string.Join(" ", result.Errors.Select(x => x.Description)));
}
return("register successful");
}
public async Task <object> Register(RegisterResource resource, IFormFile file)
{
if (!ModelState.IsValid)
{
log.Error(BadRequest((ModelState)));
return(BadRequest(ModelState));
}
var awsServiceclientSettings = new AwsServiceClientSettings(file,
_awsAppSettings.BucketName, _awsAppSettings.SubFolderW9, _awsAppSettings.BucketLocation, _awsAppSettings.PublicDomain);
var documentUrl = "";
if (file != null)
{
if (file.Length > _photoAppSettings.MaxBytes)
{
log.Error("Maximum file size exceeded");
return(BadRequest("Maximum file size exceeded"));
}
else
{
if (!_photoAppSettings.IsSupported(file.FileName))
{
log.Error("Invalid file type");
return(BadRequest("Invalid file type"));
}
else
{
documentUrl = await _awsServiceClient.UploadAsync(awsServiceclientSettings);
log.Info(documentUrl);
}
}
}
var userExist = await _userManager.FindByEmailAsync(resource.Email);
log.Info(userExist);
if (userExist != null)
{
log.Error("Email already is in use.");
return(BadRequest("Email already is in use."));
}
var user = new ApplicationUser
{
UserName = resource.Email,
Email = resource.Email,
FirstName = resource.FirstName,
LastName = resource.LastName,
Country = resource.Country,
Address = resource.Address,
State = resource.State,
PhoneNumber = resource.PhoneNumber,
BusinessName = resource.BusinessName,
RoutingNumber = resource.RoutingNumber,
AccountNumber = resource.AccountNumber,
TaxId = resource.TaxId,
OriginatingPartyName = resource.OriginatingPartyName,
ReceivingPartyName = resource.ReceivingPartyName,
BankName = resource.BankName,
W9 = ""
};
var result = await _userManager.CreateAsync(user, resource.Password);
log.Info(result);
if (result.Succeeded)
{
var roleAdd = await _userManager.AddToRoleAsync(user, resource.RoleName);
log.Info(roleAdd);
if (roleAdd.Succeeded)
{
user = await _userManager.FindByEmailAsync(resource.Email);
log.Info(user);
return(new LoginResourceResponse
{
User = user,
Roles = new[] { resource.RoleName },
Token = GenerateJwtToken(user.Email, user)
});
}
log.Error("Error during adding role to the user.");
return(BadRequest("Error during adding role to the user."));
}
log.Error("Error during user creation.");
return(BadRequest("Error during user creation."));
}
public RedirectToActionResult Register([FromBody] RegisterResource paramBody)
{
return(RedirectToActionPreserveMethod("CreateUser", "Users"));
}
