public async Task <IHttpActionResult> Put(RegisterUserData users)
{
await Initilization;
var response = await _repo.UpdateUserAsync(users);
return(Ok(response.Resource));
}
public async Task <RegistrationUserResult> RegisterUser(RegisterUserData newUser)
{
ValidatePassword(newUser);
var user = newUser.ToModel(mapper, passwordHasher);
await using var tmp = await connectionController.OpenConnectionAsync();
return(await transaction.Run(async() =>
{
try
{
user = await usersRepo.AddUser(user);
}
catch (ConnectionException)
{
throw;
}
catch (Exception e)
{
throw new UserRegistrationException(e.Message, e);
}
await notificationSender.OnUserRegistered(user.ToDto(mapper));
var token = await AuthenticateUser(user.Id);
return new RegistrationUserResult
{
User = user.ToDto(mapper),
Token = token
};
}));
}
public async Task <IActionResult> Register([FromBody] RegisterUserData registerUserData)
{
var newUser = Mapper.Map <User>(registerUserData);
newUser.Password = EncyptionProvider.HashPassword(newUser.Password);
var repositoryResponse = await Repository.RegisterUser(newUser);
if (!repositoryResponse.Successful)
{
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.EmailIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.EmailUsedError));
}
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.UserIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.LoginUsedError));
}
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.UserIndexAndEmailIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.LoginAndEmailUsedError));
}
return(new BadRequestResult());
}
BearerToken bearerToken = EncyptionProvider.CreateBearerToken(Mapper.Map <BearerToken>(repositoryResponse.Value));
return(new JsonResult(bearerToken));
}
public async Task <IActionResult> Register([FromBody] RegisterUserData registerUserData)
{
try
{
//Encrypt user password
registerUserData.Password = BC.HashPassword(registerUserData.Password);
//Check is email in use
User user = await _usersDataAccess.GetUserByEmailAsync(registerUserData.Email);
if (user != null)
{
ModelState.AddModelError("Email", "Email address is taken");
}
//Check is username in use
user = await _usersDataAccess.GetUserByUserNameAsync(registerUserData.Username);
if (user != null)
{
ModelState.AddModelError("Username", "Username is taken");
}
//If there are errors send them to client app
if (ModelState.IsValid == false)
{
return(Conflict(ModelState));
}
//Create a user from register user data
user = new User(registerUserData);
//Set user as unverified
user.IsVerified = false;
//Insert user to db
await _usersDataAccess.CreateUserAsync(user);
//Create verification token
VerificationToken token = _tokenManipulation.GenerateVerificationToken(user.Id);
//Set token purpose
token.TokenPurpose = TokenPurposeEnum.EmailVerification;
//Insert verification token in database
await _verificationTokenDataAccess.InsertVerificationTokenAsync(token);
//Send email with verification token
await _mailService.SendVerificationTokenAsync(token.Token, user);
return(Ok(new { message = $"Thank you for registering! Verification token has been sent to {user.Email}" }));
}
catch (Exception ex)
{
_logger.LogError(ex, "Server Error");
return(StatusCode(500));
}
}
private void ValidatePassword(RegisterUserData newUser)
{
if (string.IsNullOrEmpty(newUser.Password) ||
newUser.Password != newUser.RepeatedPassword)
{
throw new UserRegistrationException("Password must not be empty and must be equal to RepeatedPassword");
}
}
public ActionResult Registration(RegisterUserData user)
{
if (ModelState.IsValid)
{
using (InStepContext DB = new InStepContext())
{
UserData us = new UserData(user);
DB.UserData.Add(us);
DB.SaveChanges();
}
}
return(View(user));
}
public void submitclick(object sender, EventArgs e)
{
string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["DBConnection"].ConnectionString;
SqlConnection con = new SqlConnection(connectionString);
con.Open();
SqlCommand usernamecmd = new SqlCommand("select * from users where username=@Name", con);
SqlCommand emailcmd = new SqlCommand("select * from users where useremail=@Email", con);
usernamecmd.Parameters.AddWithValue("@Name", Username.Text);
emailcmd.Parameters.AddWithValue("@Email", Email.Text);
SqlDataReader undr = usernamecmd.ExecuteReader();
var usernameTaken = undr.HasRows;
undr.Close();
SqlDataReader edr = emailcmd.ExecuteReader();
var emailTaken = edr.HasRows;
edr.Close();
con.Close();
if (emailTaken)
{
ErrorLabel.Text = "Email already registered, please login.";
}
else if (usernameTaken)
{
ErrorLabel.Text = "Username already taken.";
}
else
{
if (Avatar.HasFile)
{
//Using a try statement allows us to output debugging problems.
try
{
string filename = Avatar.FileName;
Avatar.SaveAs(Server.MapPath("~/pictures/avatars/") + filename);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Upload status: The file could not be uploaded. The following error occured: " + ex.Message);
}
}
// Username is available
RegisterUserData.Insert();
Response.Redirect("Login.aspx");
}
}
public async Task <IHttpActionResult> Post(RegisterUserData users)
{
await Initilization;
var user = await _repo.CheckIfUserExistAsync(users.email);
if (user != null)
{
return(BadRequest());
}
var response = await _repo.ReigsterUser(users);
return(Ok(response.Resource));
}
public async Task <IHttpActionResult> PostRegister(RegisterUserData userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await _accout.RegisterUser(userModel);
//IHttpActionResult errorResult = GetErrorResult(result);
//if (errorResult != null)
//{
// return errorResult;
//}
return(Ok(result));
}
public async Task <IdentityResult> RegisterUser(RegisterUserData userModel)
{
ApplicationUser user = new ApplicationUser
{
ForeignId = userModel.ForeignId,
IsRightInfo = userModel.IsRightInfo,
IdentityNo = userModel.IdentityNo,
EnrollDate = userModel.EnrollDate,
OrganizationId = userModel.OrganizationId,
Email = userModel.Email,
PhoneNumber = userModel.PhoneNumber,
FullName = userModel.FullName,
UserName = userModel.UserName,
StaffNo = userModel.StaffNo
};
var result = await _userManager.CreateAsync(user, userModel.Password);
return result;
}
public async Task <ActionResult <RegistrationUserResult> > RegisterUser(RegisterUserData data)
{
var result = await registrationSvc.RegisterUser(data);
return(Ok(result));
}
// [ValidateAjax]
public ActionResult AddRegistration(RegisterUserData rud)
{
var captchaResponseToken = Request.Form["g-recaptcha-response"];
bool res = Common.ValidateCaptcha(captchaResponseToken);
if (!res)
{
ModelState.AddModelError(String.Empty, "Invalid Captcha"); // for summary-view only
return(Json(this.GetModelStateDictErrors(ModelState)));
}
if (ModelState.IsValid)
{
var fakeProducts = new List <Product>();
var fakeProduct = new Product
{
Demo = false,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddYears(10),
IsActive = true,
ProductId = 1,
Selected = true,
LicenseCnt = 1
};
fakeProducts.Add(fakeProduct);
var fakeClient = new ClientData();
fakeClient.ClientName = rud.Mail;
fakeClient.CountryId = 36;
fakeClient.OriginId = 1;
fakeClient.Products = fakeProducts;
var clientId = UserMng.SetClient(6510, fakeClient);
var fakeUserDataAdm = new UserDataAdm
{
Email = rud.Mail,
EmailValid = false, // consider not validating this at start
Username = rud.Mail,
UserType = UserTypes.User,
Active = true, // consider not activating this at start
Fullname = rud.Mail, // intentionally
ClientId = clientId,
Password = rud.Password,
OriginId = 1,
Products = fakeProducts
};
var userId = UserMng.SetUser(fakeUserDataAdm, 6510); // TODO: get some system id
// SEND ACTIVATION EMAIL
string subject = "Interlex account activation";
string token = UserMng.AddUservalidateToken(userId);
string applicationPath = Request.ApplicationPath != "/" ? Request.ApplicationPath : String.Empty;
string activationUrl = "http://" + Request.Url.Authority + applicationPath + "/Login/Activate/" + token;
string activationLink = "<a href=\"" + activationUrl + "\" target=\"_blank\">" + activationUrl + "</a>";
string body = Resources.Resources.UI_Registration_MailBody;
body = body.Replace("{fullname}", rud.Mail); // intentionally using mail instead of fullname
body = body.Replace("{activation_link}", activationLink);
// var model = new RegistrationEmail(activationLink, name);
// var body = base.GetViewString("~/Views/User/_RegistrationEmail.cshtml", model, language);
Mail.SendMail("*****@*****.**", "Interlex", new string[] { rud.Mail }, subject, body);
return(PartialView("AfterRegistration"));
}
return(Json(this.GetModelStateDictErrors(ModelState)));
}
