public async Task <LoginResponseModel> LoginAsync([FromBody] LoginModel model)
{
UserDbModel dbModel = await _userRepository.GetUserByUsername(model.Username);
if (dbModel == null || !BCrypt.Net.BCrypt.Verify(model.Password, dbModel.Password))
{
return(new LoginResponseModel
{
Success = false
});
}
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
byte[] key = Encoding.ASCII.GetBytes(JwtSecret);
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim("username", model.Username),
new Claim("name", dbModel.Name)
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
return(new LoginResponseModel
{
Success = true,
Token = tokenHandler.WriteToken(token)
});
}
public void ChangeUserPassword(int id, string newPassword)
{
UserDbModel currentUser = _dbContext.FilmHubUsers.Find(id);
currentUser.Password = newPassword;
_dbContext.SaveChanges();
}
public void EnsureUserExistsAsync_UserExists_ReturnedWithoutDbCall()
{
IDbContext dbContext = Substitute.For <IDbContext>();
UserInfo userInfo = new UserInfo();
userInfo.AuthId = Guid.NewGuid().ToString();
userInfo.Name = Guid.NewGuid().ToString();
userInfo.Email = Guid.NewGuid().ToString();
UserDbModel userDbModel = new UserDbModel();
userDbModel.Id = Guid.NewGuid().ToString();
userDbModel.AuthId = userInfo.AuthId;
UserRepository userRepository = Substitute.For <UserRepository>();
userRepository.GetByAuthIdAsync(dbContext, userInfo.AuthId).Returns(userDbModel);
IMapper mapper = CreateMapper();
CreateUserCommand createUserCommand = Substitute.For <CreateUserCommand>();
UserViewService userViewService = new UserViewService(dbContext, mapper, userRepository, createUserCommand);
UserViewModel result = userViewService.EnsureUserExistsAsync(userInfo).Result;
Assert.AreEqual(userInfo.AuthId, result.AuthId);
createUserCommand.DidNotReceive().ExecuteAsync(Arg.Any <IDbContext>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>()).Wait();
}
public void GetUserWorkspaces_WorkspacesExist_CachesResult()
{
string authUserId = Guid.NewGuid().ToString();
string cacheKey = CacheKeys.UserWorkspace(authUserId);
IDbContext dbContext = Substitute.For <IDbContext>();
IEnumerable <WorkspaceViewModel>?cachedViewModel = null;
UserDbModel userDbModel = new UserDbModel();
userDbModel.Workspaces = new string[1] {
"workspace1"
};
WorkspaceDbModel[] workspaceDbModels = new WorkspaceDbModel[1] {
new WorkspaceDbModel()
};
UserRepository userRepository = Substitute.For <UserRepository>();
userRepository.GetByAuthIdAsync(dbContext, authUserId).Returns <UserDbModel>(userDbModel);
WorkspaceRepository workspaceRepository = Substitute.For <WorkspaceRepository>();
workspaceRepository.GetManyByIdAsync(dbContext, userDbModel.Workspaces).Returns(workspaceDbModels);
IMemoryCacheWrapper memoryCache = Substitute.For <IMemoryCacheWrapper>();
memoryCache.Get <IEnumerable <WorkspaceViewModel> >(cacheKey).Returns(cachedViewModel);
UserWorkspaceViewService userWorkspaceViewService = new UserWorkspaceViewService(dbContext, memoryCache, Substitute.For <IMapper>(), userRepository, workspaceRepository);
IEnumerable <WorkspaceViewModel> result = userWorkspaceViewService.GetUserWorkspaces(authUserId).Result;
// assert
memoryCache.Received(1).Set <IEnumerable <WorkspaceViewModel> >(cacheKey, Arg.Any <IEnumerable <WorkspaceViewModel> >(), Arg.Any <TimeSpan>());
}
public IActionResult UserPage(string Name)
{
ViewBag.Db = _db;
UserDbModel user = _userManager.FindByNameAsync(Name).Result;
return(View(user));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
UserDbModel user = new UserDbModel {
UserName = model.Name,
QueuesAsMember = new List <int>(),
QueuesAsOuthor = new List <int>(),
QueuesAsTeacher = new List <int>(),
};
// добавляем пользователя
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// установка куки
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
public int ChangedPasswordIsCorrect(int id, string oldPassword, string newPassword, string newPasswordRepeat)
{
UserDbModel currentUser = _dbContext.FilmHubUsers.Find(id);
for (int i = 0; i < newPassword.Length; i++)
{
if (Char.IsDigit(newPassword[i]))
{
if (newPassword.Length >= 8)
{
if (newPassword == newPasswordRepeat)
{
if (newPassword != oldPassword)
{
if (currentUser.Password == oldPassword)
{
return(1);
}
}
return(2);
}
return(3);
}
return(4);
}
}
return(5);
}
public UserDbModel Login(UserDbModel dbModel)
{
using (DesarrolloDocenteBDEntities db = new DesarrolloDocenteBDEntities())
{
var login = (from user in db.SEC_USER
where user.EMAIL.ToUpper().Equals(dbModel.Email.ToUpper()) && user.USER_PASSWORD.Equals(dbModel.Password)
select user).FirstOrDefault();
if (login == null)
{
return(null);
}
var date = dbModel.CurrentDate;
SEC_SESSION session = new SEC_SESSION()
{
USERID = login.ID,
LOGIN_DATE = date,
TOKEN_STATUS = true,
TOKEN = this.GetToken(String.Concat(login.ID, date)),
IP_ADDRESS = this.GetIpAddress()
};
db.SEC_SESSION.Add(session);
db.SaveChanges();
UserModelMapper mapper = new UserModelMapper();
return(mapper.MapperT1T2(login));
}
}
public async Task <User> FindByIdAsync(int id)
{
UserDbModel userDbModel = await _userManager.FindByIdAsync(id.ToString());
var user = Mapper.Map <UserDbModel, User>(userDbModel);
IEnumerable <string> roleNames = await _userManager.GetRolesAsync(userDbModel);
var rolesTasks = new List <Task <IdentityRole> >();
foreach (string roleName in roleNames)
{
Task <IdentityRole> roleTask = _roleManager.FindByNameAsync(roleName);
rolesTasks.Add(roleTask);
}
Task.WaitAll(rolesTasks.ToArray());
foreach (Task <IdentityRole> roleTask in rolesTasks)
{
IdentityRole identityRole = roleTask.Result;
var role = Mapper.Map <IdentityRole, Role>(identityRole);
user.Roles.Add(role);
}
return(user);
}
public void EnsureUserExistsAsync_UserDoesNotExist_ReturnedAfterCreation()
{
IDbContext dbContext = Substitute.For <IDbContext>();
UserInfo userInfo = new UserInfo();
userInfo.AuthId = Guid.NewGuid().ToString();
userInfo.Name = Guid.NewGuid().ToString();
userInfo.Email = Guid.NewGuid().ToString();
UserDbModel userDbModel = new UserDbModel();
userDbModel.Id = Guid.NewGuid().ToString();
userDbModel.AuthId = userInfo.AuthId;
UserRepository userRepository = Substitute.For <UserRepository>();
userRepository.GetByAuthIdAsync(dbContext, userInfo.AuthId).Returns <UserDbModel>(x => null);
IMapper mapper = CreateMapper();
CreateUserCommand createUserCommand = Substitute.For <CreateUserCommand>();
createUserCommand.ExecuteAsync(dbContext, userInfo.AuthId, userInfo.Name, userInfo.Email).Returns(userDbModel);
UserViewService userViewService = new UserViewService(dbContext, mapper, userRepository, createUserCommand);
UserViewModel result = userViewService.EnsureUserExistsAsync(userInfo).Result;
Assert.AreEqual(userInfo.AuthId, result.AuthId);
createUserCommand.Received(1).ExecuteAsync(dbContext, userInfo.AuthId, userInfo.Name, userInfo.Email).Wait();
}
/// <summary>
/// Actualización de un registro
/// </summary>
/// <param name="dbModel"></param>
/// <returns></returns>
public int RecordUpdate(UserDbModel dbModel)
{
using (DesarrolloDocenteBDEntities db = new DesarrolloDocenteBDEntities())
{
try
{
var record = db.SEC_USER.Where(x => x.ID == dbModel.Id).FirstOrDefault();
if (record == null)
{
return(3);
}
record.NAME = dbModel.Name;
record.LASTNAME = dbModel.Lastname;
record.CELLPHONE = dbModel.Cellphone;
record.EMAIL = dbModel.Email;
record.USER_PASSWORD = dbModel.Password;
record.UPDATE_USER_ID = dbModel.UserInSessionId;
record.UPDATE_DATE = dbModel.CurrentDate;
db.SaveChanges();
return(1);
}
catch
{
return(2);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dbModel"></param>
/// <returns></returns>
public int RecordRemove(UserDbModel dbModel)
{
using (DesarrolloDocenteBDEntities db = new DesarrolloDocenteBDEntities())
{
try
{
var record = db.SEC_USER.Where(x => x.ID == dbModel.Id).FirstOrDefault();
if (record == null)
{
return(3);
}
//db.SEC_ROLE.Remove(record);
record.REMOVED = true;
record.REMOVE_DATE = dbModel.CurrentDate;
record.REMOVE_USER_ID = dbModel.UserInSessionId;
db.SaveChanges();
return(1);
}
catch
{
return(2);
}
};
}
private UserDbModel CreateTestUserDbModel(MongoDbContext dbContext, string containerName)
{
UserDbModel model = TestDbModelHelper.GetUserDbModel();
dbContext.InsertAsync <UserDbModel>(containerName, model).Wait();
return(model);
}
/// <summary>
/// Register user
/// </summary>
/// <param name="userDto"></param>
/// <returns> Success/Failure result</returns>
public async Task <bool> RegisterUser(CreateUserDto userDto)
{
if (userDto.Password != null)
{
userDto.Password = CommonHelper.EncodePasswordToBase64(userDto.Password);
}
UserDbModel userName = await _toDoDbContext.Users
.Where(p => p.UserName.ToLower() == userDto.UserName.ToLower()).FirstOrDefaultAsync();
if (userName != null) //This will prevent addition of existing username again
{
return(false);
}
UserDbModel user = _mapper.Map <UserDbModel>(userDto);
if (user.UserRole == null)
{
user.UserRole = "User";
}
_toDoDbContext.Users.Add(user);
if (await _toDoDbContext.SaveChangesAsync() == 1)
{
return(true);
}
return(false);
}
/// <inheritdoc />
/// <summary>
/// Register an user for given email, password and name
/// </summary>
/// <param name="code">Users university code id</param>
/// <param name="email">Users email</param>
/// <param name="passw">Users password</param>
/// <param name="name">Users name</param>
/// <param name="surname">Users surname</param>
/// <param name="phone">Users phone number</param>
/// <returns></returns>
public async Task <JsonWebToken> RegisterAsync(int code, string email, string passw, string name, string surname,
string phone)
{
if (string.IsNullOrWhiteSpace(email))
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmptyEmail);
}
if (string.IsNullOrWhiteSpace(name))
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmptyName);
}
if (string.IsNullOrWhiteSpace(surname))
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmptySurname);
}
if (string.IsNullOrWhiteSpace(phone))
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmptyPhone);
}
if (string.IsNullOrWhiteSpace(passw))
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmptyPassword);
}
if (!email.IsValidEmail())
{
throw new KarolinkaException(KarolinkaException.ExceptionType.NotEmail);
}
if (!passw.IsValidPassword())
{
throw new KarolinkaException(KarolinkaException.ExceptionType.NotPassword);
}
var user = await _userRepository.GetAsync(email);
if (user != null)
{
throw new KarolinkaException(KarolinkaException.ExceptionType.EmailAlreadyUsed);
}
var salt = _encrypter.GetSalt();
var password = _encrypter.GetHash(passw, salt);
user = new UserDbModel(
Guid.NewGuid(),
code,
email,
name,
surname,
phone,
password,
salt,
DateTime.UtcNow
);
await _userRepository.AddAsync(user);
return(await LoginAsync(email, passw));
}
public async Task <bool> RemoveUserFromRoleAsync(string id, string role)
{
UserDbModel user = await _userManager.FindByIdAsync(id);
var result = await _userManager.RemoveFromRoleAsync(user, role);
return(result.Succeeded);
}
private User GetUser(UserDbModel userDbModel)
{
return(new User
{
Name = userDbModel.Name,
Conditions = userDbModel.Conditions
});
}
public async Task <bool> AddUserToRoleAsync(string name, string role)
{
UserDbModel user = await _userManager.FindByNameAsync(name);
var result = await _userManager.AddToRoleAsync(user, role);
return(result.Succeeded);
}
private IEnumerable <Claim> GetUserRoleClaims(UserDbModel user)
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString()));
claims.Add(new Claim(ClaimTypes.Role, user.UserPermissionType.ToString()));
return(claims);
}
public async Task AddToRoleAsync(int id, string role)
{
UserDbModel user = await _userManager.FindByIdAsync(id.ToString());
if (user != null)
{
await _userManager.AddToRoleAsync(user, role);
}
}
public async Task <bool> SoftDeleteAsync(string id)
{
UserDbModel model = await _userManager.FindByIdAsync(id);
model.IsDeleted = true;
var result = await _userManager.UpdateAsync(model);
return(result.Succeeded);
}
public async Task DeleteAsync(int id)
{
UserDbModel userDbModel = await _userManager.FindByIdAsync(id.ToString());
if (userDbModel != null)
{
await _userManager.DeleteAsync(userDbModel);
}
}
internal static UserDbModel GetUserDbModel(string?authId = null, string?userName = null, string?email = null)
{
UserDbModel userDbModel = new UserDbModel();
userDbModel.AuthId = authId ?? Guid.NewGuid().ToString();
userDbModel.UserName = userName ?? Guid.NewGuid().ToString();
userDbModel.Email = email ?? Guid.NewGuid().ToString();
return(userDbModel);
}
public static User FromDbModel(UserDbModel model)
{
return(new User
{
Id = model.Id,
Password = model.Password,
Login = model.Login
});
}
public User GetUser(string name, string password)
{
UserDbModel userDbModel = _databaseService.GetUser(name);
if (userDbModel == null || _cryptographyService.sha256(password) != userDbModel.HashedPassword)
{
return(null);
}
return(GetUser(userDbModel));
}
private IEnumerable <Claim> GetUserClaims(UserDbModel user)
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString()));
claims.Add(new Claim(ClaimTypes.Name, user.UserFirstName));
claims.Add(new Claim(ClaimTypes.Email, user.UserEmail));
claims.AddRange(this.GetUserRoleClaims(user));
return(claims);
}
/// <summary>
/// Get specific user.
/// </summary>
/// <param name="userId">userId</param>
/// <returns>Returns UserDto</returns>
public async Task <UserDto> GetById(long userId)
{
UserDbModel user = await _toDoDbContext.Users.Where(p => p.UserId == userId).SingleOrDefaultAsync();
if (null == user)
{
return(null);
}
return(_mapper.Map <UserDto>(user));
}
public bool IsExpert(int currentUserId)
{
UserDbModel currentUser = _dbContext.FilmHubUsers.Find(currentUserId);
if (currentUser.IsExpert)
{
return(true);
}
return(false);
}
public async Task <string> CreateAsync(UserDbModel model)
{
if (model.PasswordHash == null)
{
model.PasswordHash = ConstantsValue.DefaultPassword;
}
var result = await _userManager.CreateAsync(model, model.PasswordHash);
return(model.Id);
}
public void UserDelete(UserDbModel item)
{
var model = users.FirstOrDefault(i => i.Id == item.Id);
if (model != null)
{
Entry(model).State = EntityState.Detached;
Entry(item).State = EntityState.Deleted;
}
}
