public async Task <IActionResult> PutUserSignupModel(int id, UserSignupModel userSignupModel)
{
if (id != userSignupModel.Id)
{
return(BadRequest());
}
_context.Entry(userSignupModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserSignupModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Post([FromBody] UserSignupModel signupModel)
{
try
{
const string user = "******";
if (signupModel.Password.Length < 8)
{
throw new UserInputException("Password must be at least 8 characters");
}
ValidateModel(signupModel);
var result = _webPageHelper.SignUp(signupModel, user);
return(Ok(result));
}
catch (UserInputException ex)
{
_logger.Error(ex.Message);
return(StatusCode((int)HttpStatusCode.NotAcceptable, ex.Message));
}
catch (Exception ex)
{
_logger.Error($"Unhandled exception occurred when attempting to sign up", ex);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <bool> AddUser([FromBody] UserSignupModel model)
{
var user = new ApplicationUser {
Name = model.name, UserName = model.email, Email = model.email
};
var result = await _userManager.CreateAsync(user, model.password);
if (result.Succeeded)
{
var roles = await _userManager.AddToRoleAsync(user, model.role);
if (roles.Succeeded)
{
var lstRoles = await _userManager.GetRolesAsync(user);
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Id", user.Id));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
}
return(true);
}
else
{
return(false);
}
}
public UserReturnModel SignUp(UserSignupModel signupModel, string userName)
{
if (!CheckCreditCardInformation(signupModel))
{
throw new UserInputException("Credit card information must be provided for any non-free account");
}
var existingUser = _userManager.GetUserByEmail(signupModel.EmailAddress);
if (existingUser != null)
{
throw new UserInputException($"Account already exists for email address '{signupModel.EmailAddress}'");
}
var tier = _standardPricingTierManager.GetStandardPricingTier(signupModel.PricingTierId);
if (tier == null)
{
throw new UserInputException($"Could not find AccountTypeId {signupModel.PricingTierId}");
}
var user = _userManager.AddNewuser(signupModel, tier, userName);
_userManager.SetStandardSettings(user.UserId);
return(MapUserToModel(user));
}
public async Task <UserLoginResponseModel> SignupEmail(UserSignupModel model)
{
if (model == null)
{
throw new ModelDamagedException("Model is required");
}
var user = await _appUserManager.FindByEmailAsync(model.Email);
if (user != null)
{
throw new MRSystemException("Email already used");
}
user = _mapper.Map <AppUser>(model);
var userCreateResult = await _appUserManager.CreateAsync(user, model.Password);
if (!userCreateResult.Succeeded)
{
throw new MRSystemException("Can not create user");
}
return(await AuthUserWithToken(user));
}
public async Task <IActionResult> RegisterUser(UserSignupModel userSignupModel)
{
if (ModelState.IsValid)
{
IdentityUser identityUser = new IdentityUser
{
UserName = userSignupModel.UserName,
Email = userSignupModel.Email
};
IdentityResult result = await _authService.Signup(identityUser, userSignupModel.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(identityUser, false);
return(Ok(_mapper.Map <AuthOutgoingDto>(identityUser))); // TODO make created action
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
IEnumerable <string> errorList = ModelState.SelectMany(m => m.Value.Errors.Select(e => e.ErrorMessage));
return(StatusCode(400, errorList));
}
public async Task <IActionResult> RegisterUser([FromBody] UserSignupModel userModel)
{
if (string.IsNullOrEmpty(userModel.Password) || string.IsNullOrEmpty(userModel.UserName))
{
return(BadRequest());
}
var user = new IdentityUser()
{
Email = userModel.Email,
UserName = userModel.UserName
};
var createUserResult = await userManager.CreateAsync(user, userModel.Password);
if (createUserResult.Succeeded)
{
await userManager.AddClaimsAsync(user, new[] { new Claim("UserId", user.Id), new Claim("UserName", user.UserName) });
//Decoupling domain users from Identity framework, by correlating a domain user with the identity.
modelDb.Users.Add(new Student
{
UserName = user.UserName, //correlation
Email = userModel.Email,
FullName = userModel.FullName,
isTeacher = false,
});
await modelDb.SaveChangesAsync();
}
return(Ok(createUserResult));
}
public async Task <ActionResult <UserSignupModel> > PostUserSignupModel(UserSignupModel userSignupModel)
{
_context.userSignupModels.Add(userSignupModel);
await _context.SaveChangesAsync();
return(StatusCode(201));
// return CreatedAtAction("GetUserSignupModel", new { id = userSignupModel.Id }, userSignupModel);
}
public async Task <IActionResult> SignupEmail([FromBody] UserSignupModel model)
{
if (!ModelState.IsValid)
{
return(BadModelResponse());
}
return(Ok(await _loginManager.SignupEmail(model)));
}
public void Post_GoodPassword()
{
//arrange
var model = new UserSignupModel
{
Password = "******"
};
//act
var result = _webPageController.Post(model);
//assert
AssertWithMessage.IsOfType(result, typeof(OkObjectResult));
}
public void SignUp_NoCreditCardWithNonFreeAccount()
{
const string user = "******";
//arrange
var signupModel = new UserSignupModel
{
CreditCardNumber = null,
PricingTierId = (byte)StaticData.StaticPricingTier.Standard
};
//act / assert
var ex = Assert.Throws <UserInputException>(() => _webPageHelper.SignUp(signupModel, user));
AssertWithMessage.AreEqual(ex.Message, "Credit card information must be provided for any non-free account", "exception message");
}
public async Task <ActionResult> SignUp(UserSignupModel model)
{
if (ModelState.IsValid)
{
var user = new AppUser {
UserName = model.UserName, Nickname = model.NickName, PhoneNumber = model.PhoneNumber, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Redirect("/Account/Login"));
}
AddErrorsFromResult(result);
}
return(View(model));
}
public async Task <ActionResult> Signup(UserSignupModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// signup
var signupRequest = _mapper.Map <SignupUserServiceRequest>(model);
await _identityService.SignupAsync(signupRequest);
// begin session
var userSession = _mapper.Map <UserSessionModel>(model);
_userSession.EnstablishSession(userSession);
return(Redirect(_redirectUrlProvider.RedirectUrl));
}
public void Post_BadPassword()
{
//arrange
var model = new UserSignupModel
{
Password = "******"
};
//act
var result = _webPageController.Post(model);
//assert
AssertWithMessage.IsOfType(result, typeof(ObjectResult));
var response = result as ObjectResult;
AssertWithMessage.AreEqual(response.StatusCode, (int)HttpStatusCode.NotAcceptable, "status code");
AssertWithMessage.AreEqual(response.Value.ToString(), "Password must be at least 8 characters", "exception message");
}
public void SignUp_ExistingPricingTier()
{
const string user = "******";
//arrange
var signupModel = new UserSignupModel
{
CreditCardNumber = null,
PricingTierId = (byte)StaticData.StaticPricingTier.Free
};
_userManager.Setup(x => x.GetUserByEmail(signupModel.EmailAddress)).Returns(default(User));
_standardPricingTierManager.Setup(x => x.GetStandardPricingTier(signupModel.PricingTierId)).Returns(default(StandardPricingTier));
//act / assert
var ex = Assert.Throws <UserInputException>(() => _webPageHelper.SignUp(signupModel, user));
AssertWithMessage.AreEqual(ex.Message, $"Could not find AccountTypeId {signupModel.PricingTierId}", "exception message");
}
public void SignUp_ExistingEmail()
{
const string user = "******";
const string emailAddress = "emailAddress";
//arrange
var signupModel = new UserSignupModel
{
CreditCardNumber = null,
EmailAddress = emailAddress,
PricingTierId = (byte)StaticData.StaticPricingTier.Free
};
_userManager.Setup(x => x.GetUserByEmail(signupModel.EmailAddress)).Returns(new User());
//act / assert
var ex = Assert.Throws <UserInputException>(() => _webPageHelper.SignUp(signupModel, user));
AssertWithMessage.AreEqual(ex.Message, $"Account already exists for email address '{signupModel.EmailAddress}'", "exception message");
}
private bool CheckCreditCardInformation(UserSignupModel userSignupModel)
{
if (userSignupModel.PricingTierId == (byte)StaticData.StaticPricingTier.Free)
{
return(true);
}
if (string.IsNullOrEmpty(userSignupModel.FirstName) ||
string.IsNullOrEmpty(userSignupModel.LastName) ||
string.IsNullOrEmpty(userSignupModel.AddressLine1) ||
string.IsNullOrEmpty(userSignupModel.City) ||
string.IsNullOrEmpty(userSignupModel.State) ||
string.IsNullOrEmpty(userSignupModel.ZipCode) ||
string.IsNullOrEmpty(userSignupModel.CreditCardNumber) ||
string.IsNullOrEmpty(userSignupModel.CreditCardExpirationDate) ||
string.IsNullOrEmpty(userSignupModel.CreditCardCvcCode))
{
return(false);
}
return(true);
}
public ActionResult Signup(UserSignupModel model)
{
if (ModelState.IsValid)
{
var check = userService.CheckAccountExists(model.UserName_S);
if (check)
{
//var user = Mapper.Map<User>(model); if UserName not S then OK
User user = new User();
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.UserName_S;
user.PasswordHash = PasswordHashMD5.MD5Hash(model.Password_S);
user.DateOfBirth = DateTime.Now;
user.Gender = true;
user.Avatar = "AvatarDefault-Male.png";
userService.Add(user);
var _user = userService.GetUser(model.UserName_S, PasswordHashMD5.MD5Hash(model.Password_S));
var userRole = new UserRole();
userRole.UserId = _user.UserId;
userRole.RoleId = roleService.GetByName(Common.Role.MEMBER).First().RoleId;
userRoleService.Add(userRole);
var roles = userRoleService.GetByUserId(_user.UserId);
Session[UserSession.UserId] = _user.UserId;
Session[UserSession.FullName] = model.FirstName + " " + model.LastName;
Session[UserSession.Avatar] = _user.Avatar;
Session[UserSession.Role] = roles;
return(Redirect("/Home/Index"));
}
else
{
TempData["statusSignup"] = false;
TempData["messageSignup"] = "Tên đăng nhập đã tồn tại.Vui lòng kiểm tra lại.";
}
}
return(View("Index"));
}
public User AddNewuser(UserSignupModel signupModel, StandardPricingTier tier, string userName)
{
var apiToken = Guid.NewGuid();
var passwordBytes = Encoding.ASCII.GetBytes(signupModel.Password);
var password = _passwordHelper.GenerateSecurePassword(passwordBytes);
var user = new User
{
ApiToken = apiToken,
CallsPerMonth = tier.CallsPerMonth,
CanCallApi = true,
FirstName = signupModel.FirstName,
LastName = signupModel.LastName,
Email = signupModel.EmailAddress,
PricePerMonth = tier.PricePerMonth,
Password = password,
CreatedBy = userName,
CreatedDate = DateTime.UtcNow,
UpdatedBy = userName,
CreditCardNumber = !string.IsNullOrEmpty(signupModel.CreditCardNumber) ? long.Parse(signupModel.CreditCardNumber) : default(decimal?),
CreditCardCvcCode = signupModel.CreditCardCvcCode,
CreditCardExpirationDate = signupModel.CreditCardExpirationDate,
UpdatedDate = DateTime.UtcNow,
AddressLine1 = signupModel.AddressLine1,
AddressLine2 = signupModel.AddressLine2,
City = signupModel.City,
State = signupModel.State,
ZipCode = signupModel.ZipCode
};
_context.User.Add(user);
_context.SaveChanges();
return(user);
}
public void BeforeEach()
{
_classUnderTest = new UserSignupModel();
}
public async Task <UserStatusModel> SignUp(UserSignupModel model)
{
var exists = await _managerUser.FindByEmailAsync(model.Email);
if (exists != null)
{
throw new MRException <UserStatusModel>((int)ExceptionCode.SYSTEM_EXCEPTION, "User with this email already exists");
}
var user = _mapper.Map <User>(model);
var saveResult = await _managerUser.CreateAsync(user);
if (!saveResult.Succeeded)
{
throw new MRException <UserStatusModel>((int)ExceptionCode.SYSTEM_EXCEPTION, "Can not create user");
}
await _managerUser.AddPasswordAsync(user, model.Password);
await _managerUser.AddToRoleAsync(user, AppRoles.USER.ToString());
string providerToken = null;
if (!string.IsNullOrWhiteSpace(model.ProviderSlug))
{
var provider = await _repositoryProvider.GetFirst(x => x.Slug == model.ProviderSlug && x.State == MREntityState.Active);
if (provider != null)
{
if (!provider.Options.IsRegistrationAvaliable)
{
throw new MRException <object>(-1, "Provider registration disabled");
}
providerToken = ProviderTokenGenerator.Generate(provider.Id, user.Id);
}
}
var token = _serviceToken.GenerateToken(user.Id, user.Email, new List <string> {
AppRoles.USER.ToString()
});
var response = new UserStatusModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
AccessToken = token,
Roles = new List <string> {
AppRoles.USER.ToString()
},
LanguageCode = user.LanguageCode,
Sex = user.Sex,
CallbackUrl = model.CallbackUrl,
CallbackToken = providerToken,
IsEmailConfirmed = false,
IsEmailOnChange = false
};
return(response);
}
public async Task <IActionResult> SignUp([FromBody] UserSignupModel model)
{
return(Json(await _managerUserControl.SignUp(model)));
}
public void SignUp_Successful()
{
const string user = "******";
const string creditCardNumber = "4444333322221111";
const string firstName = "firstName";
const string lastName = "lastName";
const string email = "email";
const byte pricingTierId = (byte)StaticData.StaticPricingTier.Standard;
const int userId = 1;
const int callsPerMonth = 100;
const string pricingTierName = "pricingTierName";
const decimal pricePerMonth = 100;
const string addressLine1 = "addressLine1";
const string addressLine2 = "addressLine2";
const string city = "city";
const string state = "state";
const string zipCode = "zipCode";
const string cvcCode = "cvcCode";
const string expirationDate = "expirationDate";
const string password = "******";
//arrange
var signupModel = new UserSignupModel
{
CreditCardNumber = creditCardNumber,
PricingTierId = pricingTierId,
EmailAddress = email,
FirstName = firstName,
LastName = lastName,
AddressLine1 = addressLine1,
AddressLine2 = addressLine2,
City = city,
State = state,
ZipCode = zipCode,
CreditCardCvcCode = cvcCode,
CreditCardExpirationDate = expirationDate,
Password = password
};
_standardPricingTierManager.Setup(x => x.GetStandardPricingTier(pricingTierId)).Returns(new StandardPricingTier
{
CallsPerMonth = callsPerMonth,
Name = pricingTierName,
PricePerMonth = pricePerMonth,
StandardPricingTierId = pricingTierId
});
_userManager.Setup(x => x.AddNewuser(It.IsAny <UserSignupModel>(), It.IsAny <StandardPricingTier>(), It.IsAny <string>())).Returns(new User
{
UserId = userId
});
//act
_webPageHelper.SignUp(signupModel, user);
//assert
_userManager.Verify(x => x.AddNewuser(It.Is <UserSignupModel>(m =>
m.CreditCardNumber == creditCardNumber &&
m.EmailAddress == email &&
m.FirstName == firstName &&
m.LastName == lastName &&
m.PricingTierId == pricingTierId &&
m.AddressLine1 == addressLine1 &&
m.AddressLine2 == addressLine2 &&
m.City == city &&
m.State == state &&
m.ZipCode == zipCode &&
m.CreditCardCvcCode == cvcCode &&
m.CreditCardExpirationDate == expirationDate &&
m.Password == password),
It.Is <StandardPricingTier>(m =>
m.CallsPerMonth == callsPerMonth &&
m.Name == pricingTierName &&
m.PricePerMonth == pricePerMonth &&
m.StandardPricingTierId == pricingTierId
), user
));
_userManager.Verify(x => x.SetStandardSettings(userId));
}
