private void UpdateUserFromProfile(Domain.Entity.User userEntity, UserModel userProfile)
{
userEntity.Email = userProfile.Email;
userEntity.Name = userProfile.Name;
userEntity.Surname = userProfile.Surname;
userEntity.PhotoUrl = userProfile.PhotoUrl;
}
public ActionResult Login(UserModel objmodel)
{
if (objmodel.FormType == "Login")
{
return(CreateLogin(objmodel));
}
else
{
ChatApp.Domain.Entity.User objentity = new Domain.Entity.User();
objentity.CreatedOn = System.DateTime.Now;
objentity.IsActive = true;
objentity.Name = objmodel.Name;
objentity.Password = objmodel.Password1;
objentity.UpdatedOn = System.DateTime.Now;
objentity.UserName = objmodel.UserName1;
objentity.DOB = Convert.ToDateTime(objmodel.DOB);
objentity.Gender = objmodel.Gender;
var result = _UserRepo.SaveUser(objentity);
if (!string.IsNullOrEmpty(result.Item2))
{
objmodel.Error = result.Item2;
TempData["ReturnFrom"] = "SignUp";
return(View("Login", objmodel));
}
objmodel.UserName = objmodel.UserName1;
objmodel.Password = objmodel.Password1;
return(CreateLogin(objmodel));
}
}
public ActionResult CreateNewAccount(RegisterViewModel model, String returnUrl)
{
if (ModelState.IsValid)
{
var userManager = HttpContext.GetOwinContext().GetUserManager <AppUserManager>();
var roleManager = HttpContext.GetOwinContext().GetUserManager <RoleManager <AppRole> >();
User user = new Domain.Entity.User()
{
UserName = model.Login,
Email = model.EMail,
UserProfile = new UserProfile()
{
FirstName = model.FirstName,
LastName = model.LastName,
Age = model.Age,
}
};
IdentityResult result = userManager.Create(user, model.Password);
userManager.AddToRole(userManager.FindByName(user.UserName).Id, "User");
if (result.Succeeded)
{
return(Redirect(returnUrl ?? Url.Action("SignIn", "Access")));
}
}
ModelState.AddModelError("", "Rejestracja nie powiodła się!");
return(View());
}
public UserServiceTests()
{
_user = new Domain.Entity.User {
Name = "Name User"
};
_userRepository = new Mock <IRepository <Data.Entity.User> >();
_userService = new UserService(_userRepository.Object);
}
public void UserService_IsValid_return_false_when_name_is_empty()
{
var user = new Domain.Entity.User();
var errorMessages = new List <string>();
var expected = _userService.IsValid(user, out errorMessages);
Assert.IsFalse(expected);
Assert.IsTrue(errorMessages.Any());
}
public async Task <UserModel> CreateUserAsync(string userName, string password)
{
var user = new Domain.Entity.User
{
UserName = userName,
EncryptedPassword = password
};
await _userRepository.AddAsync(user);
return(ToUserModel(user));
}
private void ValidateUser(Domain.Entity.User userData, string password)
{
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException(nameof(password));
}
if (_passwordCryptor.IsPasswordsEquals(userData.EncryptedPassword, password))
{
throw new InvalidDataException("Invalid password");
}
}
private UserModel ToUserModel(Domain.Entity.User user)
{
return(new UserModel
{
Id = user.Id,
Name = user.Name,
Surname = user.Surname,
Email = user.Email,
PhotoUrl = user.PhotoUrl,
UserName = user.UserName
});
}
//public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
//{
// throw new NotImplementedException();
//}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
#region Check valid username
if (!SecurityUtility.IsUsernameValid(username))
{
status = MembershipCreateStatus.InvalidUserName;
return(null);
}
#endregion
#region Check for valid PersonId
string _username = username;
string _domain = string.Empty;
try
{
if (SecurityUtility.UsernameContainsDomain(username))
{
_username = SecurityUtility.ExtractUsername(username);
_domain = SecurityUtility.ExtractDomain(username);
}
}
catch
{
// Username was flagged as having a domain attached, but the extraction failed for unknown reason
status = MembershipCreateStatus.InvalidUserName;
return(null);
}
Guid personId;
bool locked = false;
try
{
if (providerUserKey != null && providerUserKey.ToString().Length >= 32)
{
personId = new Guid(providerUserKey.ToString().Substring(0, 32));
locked = ValueUtilities.GetBoolean(providerUserKey.ToString().Substring(32), false);
}
else if (providerUserKey == null || providerUserKey.ToString().Length == 0)
{
personId = Guid.Empty;
}
else
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return(null);
}
}
catch
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return(null);
}
#endregion
#region Test for valid email
//if ((RequiresUniqueEmail || EnablePasswordRetrieval || EnablePasswordReset) && !password.Equals(SOCIAL_LOGIN_DEFAULT_PASSWORD))
//{
// if (email == null || EmailUtilities.ValidateEmailAddress(email) == false)
// {
// status = MembershipCreateStatus.InvalidEmail;
// return null;
// }
//}
#endregion
#region Test for valid password
if (!SecurityUtility.IsPasswordValid(password))
{
status = MembershipCreateStatus.InvalidPassword;
return(null);
}
#endregion
IRepositoryProvider _repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), _repositoryProvider);
#region Check for unique username
Domain.Entity.User user = unitofWork.Repository <User>().Query(u => String.Compare(u.UserName, username, StringComparison.InvariantCultureIgnoreCase) == 0).Select().FirstOrDefault();
if (user != null)
{
status = MembershipCreateStatus.DuplicateUserName;
return(null);
}
#endregion
#region Test for valid question/answer
if (RequiresQuestionAndAnswer)
{
if (passwordQuestion == null || passwordQuestion.Length > 200 || passwordQuestion.Length < 1)
{
status = MembershipCreateStatus.InvalidQuestion;
return(null);
}
if (passwordAnswer == null || passwordAnswer.Length > 200 || passwordAnswer.Length < 1)
{
status = MembershipCreateStatus.InvalidAnswer;
return(null);
}
}
#endregion
DateTime dt = DateTime.Now;
user = new User
{
UserName = _username,
CreationDate = dt,
Domain = _domain,
PersonId = personId,
Locked = locked,
FailedLoginTimes = 0,
CurrentLanguage = System.Threading.Thread.CurrentThread.CurrentCulture.ToString()
};
user.Password = Cryptography.EncryptPassword(password, user.Salt);
try
{
unitofWork.RepositoryAsync <Domain.Entity.User>().Insert(user);
unitofWork.SaveChanges();
}
catch
{
status = MembershipCreateStatus.UserRejected;
// Log.Debug(this, string.Format("Create new user: {0} - failed", identity.Username));
return(null);
}
status = MembershipCreateStatus.Success;
//Log.Debug(this, string.Format("Create new user: {0} - successfully", identity.Username));
return(new MembershipUser(_providerName, username, providerUserKey, email, passwordQuestion, "", isApproved, false, dt, dt, dt, dt, DateTime.MinValue));
}
