public async Task <UserGetModel> NewUser(UserPutModel newUser)
{
var user = new AppUser
{
Email = newUser.Email,
UserName = newUser.Email,
};
var result = await UserManager.CreateAsync(user, newUser.Password);
if (!result.Succeeded)
{
return(null);
}
try
{
await UserManager.AddToRoleAsync(user, "Customer");
}
catch (DbUpdateException)
{
}
var roles = await UserManager.GetRolesAsync(user);
var dto = new UserGetModel
{
Id = user.Id,
CustomerId = user.CustomerId,
UserName = user.UserName,
Email = user.Email,
Roles = roles
};
return(dto);
}
public IActionResult UpdateUser([FromBody] UserGetModel userData)
{
//User addedBy = _userService.GetCurrentUser(HttpContext);
//var result = _userService.Delete(id, addedBy);
//if (result == null)
//{
// return Forbid("You don't have rigts to perform this action!");
//}
//return Ok(result);
User currentLogedUser = _userService.GetCurrentUser(HttpContext);
if (currentLogedUser.UserRole == UserRole.Admin)
{
User getUser = _userService.GetById(userData.Id);
}
var result = _userService.Update(userData.Username, userData.FirstName, userData.LastName, userData.Email, userData.UserRole, userData.Id);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public UserGetModel Authenticate(string username, string password)
{
var user = context.Users.SingleOrDefault(x => x.Username == username && x.Password == ComputeSha256Hash(password));
// return null if user not found
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Username.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var result = new UserGetModel
{
Id = user.Id,
Email = user.Email,
Username = user.Username,
Token = tokenHandler.WriteToken(token)
};
return(result);
}
public UserGetModel Upsert(int id, UserPostModel userPostModel)
{
var existing = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
//User UserAdd = User.ToUser(user);
userPostModel.Password = ComputeSha256Hash(userPostModel.Password);
User toAdd = UserPostModel.ToUser(userPostModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
//User UserUp = User.ToUser(user);
userPostModel.Password = ComputeSha256Hash(userPostModel.Password);
User toUpdate = UserPostModel.ToUser(userPostModel);
toUpdate.Id = id;
context.Users.Update(toUpdate);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
public UserGetModel GetById(int id)
{
User user = context.Users
.FirstOrDefault(u => u.Id == id);
return(UserGetModel.FromUser(user));
}
public UserGetModel Create(UserPostModel userModel)
{
User toAdd = UserPostModel.ToUser(userModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
public void ValidGetAllShouldReturnAllUsers()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAllShouldReturnAllUsers))
.Options;
using (var context = new MoviesDbContext(options))
{
var userService = new UsersService(context, config);
var addedUser1 = new WebApplication3.ViewModels.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "ovi1",
LastName = "todea1",
Password = "******",
Username = "******"
};
var addedUser2 = new WebApplication3.ViewModels.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "ovi1",
LastName = "todea1",
Password = "******",
Username = "******"
};
var addedUser3 = new WebApplication3.ViewModels.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "ovi1",
LastName = "todea1",
Password = "******",
Username = "******"
};
UserGetModel user1 = userService.Register(addedUser1);
UserGetModel user2 = userService.Register(addedUser2);
UserGetModel user3 = userService.Register(addedUser3);
List <UserGetModel> actual = new List <UserGetModel>();
user1.Token = null;
user2.Token = null;
user3.Token = null;
actual.Add(user1);
actual.Add(user2);
actual.Add(user3);
IEnumerable <UserGetModel> result = userService.GetAll();
IEnumerable <UserGetModel> expected = actual.AsEnumerable();
Assert.IsTrue(expected.SequenceEqual(actual));
}
}
public IEnumerable <UserGetModel> FilterUsersByCountRes(int count)
{
var result = _dbContext.Users
.Include(u => u.Reservations)
.ToList();
return(result.Select(u => UserGetModel.GetUserModel(u, _dbContext))
.Where(u => u.CountReservations >= count));
}
public void ValidGetAllShouldReturnAllUsers()
{
var options = new DbContextOptionsBuilder <UserDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAllShouldReturnAllUsers))
.Options;
using (var context = new UserDbContext(options))
{
var userService = new UserService(context, config);
var addedUser1 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfg",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addedUser2 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfgh",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addedUser3 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfgh",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
UserGetModel user1 = userService.Register(addedUser1);
UserGetModel user2 = userService.Register(addedUser2);
UserGetModel user3 = userService.Register(addedUser3);
List <UserGetModel> actual = new List <UserGetModel>();
user1.Token = null;
user2.Token = null;
user3.Token = null;
actual.Add(user1);
actual.Add(user2);
actual.Add(user3);
IEnumerable <UserGetModel> result = userService.GetAll();
IEnumerable <UserGetModel> expected = actual.AsEnumerable();
Assert.IsTrue(expected.SequenceEqual(actual));
}
}
public void ValidGetAllShouldReturnAllUsers()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAllShouldReturnAllUsers))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userService = new UsersService(context, config);
var addedUser1 = new Laborator2.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "aaa",
LastName = "bbb",
Password = "******",
Username = "******"
};
var addedUser2 = new Laborator2.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "bbb",
LastName = "ccc",
Password = "******",
Username = "******"
};
var addedUser3 = new Laborator2.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "ccc",
LastName = "ddd",
Password = "******",
Username = "******"
};
UserGetModel user1 = userService.Register(addedUser1);
UserGetModel user2 = userService.Register(addedUser2);
UserGetModel user3 = userService.Register(addedUser3);
List <UserGetModel> actual = new List <UserGetModel>();
user1.Token = null;
user2.Token = null;
user3.Token = null;
actual.Add(user1);
actual.Add(user2);
actual.Add(user3);
IEnumerable <UserGetModel> result = userService.GetAll();
IEnumerable <UserGetModel> expected = actual.AsEnumerable();
Assert.IsTrue(expected.SequenceEqual(actual));
}
}
public UserGetModel Delete(int id)
{
var existing = context.Users.FirstOrDefault(u => u.Id == id);
if (existing == null)
{
return(null);
}
context.Users.Remove(existing);
context.SaveChanges();
return(UserGetModel.FromUser(existing));
}
public UserGetModel Delete(int id, User addedBy)
{
var existing = context
.Users
.Include(x => x.HistoryUserRole)
.ThenInclude(x => x.UserRole)
.FirstOrDefault(u => u.Id == id);
string addedByCurrentRole = getLatestHistoryUserRole(addedBy.HistoryUserRole).UserRole.Name;
string existingCurrentRole = getLatestHistoryUserRole(existing.HistoryUserRole).UserRole.Name;
if (existing == null)
{
return(null);
}
if (addedByCurrentRole.Equals(RoleConstants.MODERATOR))
{
// https://www.aspforums.net/Threads/289493/Get-Number-of-months-between-two-dates-in-C/
var dateRegister = addedBy.DateRegister;
var dateCurrent = DateTime.Now;
int months = dateCurrent.Subtract(dateRegister).Days / 30;
if (months >= 6)
{
context.Users.RemoveRange(context.Users.Where(u => u.Id == existing.Id));
context.SaveChanges();
context.HistoryUserRoles.RemoveRange(context.HistoryUserRoles.Where(u => u.User.Id == existing.Id));
context.SaveChanges();
context.Users.Remove(existing);
// context.SaveChanges();
return(UserGetModel.FromUser(existing));
}
return(null);
// dbcontext.Users.Update(toAdd);
//dbcontext.SaveChanges();
//return toAdd;
}
if (addedByCurrentRole.Equals(RoleConstants.ADMIN))
{
context.Users.RemoveRange(context.Users.Where(u => u.Id == existing.Id));
context.SaveChanges();
context.HistoryUserRoles.RemoveRange(context.HistoryUserRoles.Where(u => u.User.Id == existing.Id));
context.SaveChanges();
context.Users.Remove(existing);
//context.SaveChanges();
return(UserGetModel.FromUser(existing));
}
return(null);
}
public void GetById()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetById))
.Options;
using (var context = new UsersDbContext(options))
{
var usersService = new UserService(context, config);
var defaultuserRole = new UserRole
{
Name = RoleConstants.ADMIN
};
context.UserRoles.Add(defaultuserRole);
context.SaveChanges();
context.Entry(defaultuserRole).State = EntityState.Detached;
UserRole userRole = new UserRole
{
Name = RoleConstants.ADMIN
};
HistoryUserRole history = new HistoryUserRole
{
UserRole = userRole,
};
List <HistoryUserRole> list = new List <HistoryUserRole>
{
history
};
User user = new User
{
Username = "******",
HistoryUserRole = list,
DateRegister = DateTime.Now,
Password = "******",
Email = "*****@*****.**",
FirstName = "trolallaa",
LastName = "tralalalal"
};
context.Users.Add(user);
context.SaveChanges();
User expected = context.Users.AsNoTracking()
.FirstOrDefault(x => x.FirstName.Equals(user.FirstName));
UserGetModel actual = usersService.GetById(expected.Id);
Assert.AreEqual(expected.Username, actual.Username);
Assert.AreEqual(expected.Id, actual.Id);
}
}
private void SetupUserPutModel()
{
userGetModel = new UserGetModel
{
Id = authId,
CustomerId = 1,
UserName = email,
Email = email,
Roles = new List <string>
{
standardRole
}
};
}
public IActionResult GetUser()
{
var autorizedUserId = AuthorizedUserId;
var user = new UserGetModel(_repository.User.GetUserById(autorizedUserId));
if (user.IsNull())
{
_logger.LogError(string.Format(Resource.LogErrorGetByIsNull, nameof(user), nameof(autorizedUserId), autorizedUserId));
return(NotFound());
}
_logger.LogInfo(string.Format(Resource.LogInfoGetById, nameof(user), autorizedUserId));
return(Ok(user));
}
public IActionResult Put(int id, [FromBody] UserPostModel userPostModel)
{
User currentLogedUser = userService.GetCurrentUser(HttpContext);
var regDate = currentLogedUser.DataRegistered;
var currentDate = DateTime.Now;
var minDate = currentDate.Subtract(regDate).Days / (365 / 12);
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser == null)
{
return(NotFound());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.Admin)
{
return(Forbid());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.UserManager && minDate <= 6)
{
return(Forbid());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.UserManager && minDate >= 6)
{
var result1 = userService.Upsert(id, userPostModel);
return(Ok(result1));
}
}
var result = userService.Upsert(id, userPostModel);
return(Ok(result));
}
public object Get(UserGetModel m)
{
if (m.EventId != null)
{
Event event_ = (from e in DataContext.Event
where e.Id == m.EventId
select e).FirstOrDefault();
return(event_.Users);
}
return((from u in DataContext.User
where u.Id == m.Id
select u).FirstOrDefault());
//if(eventId)
}
public UserGetModel Upsert(int id, UserPostModel userPostModel)
{
var existing = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
User toAdd = UserPostModel.ToUser(userPostModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
User toUpdate = UserPostModel.ToUser(userPostModel);
toUpdate.Id = id;
context.Users.Update(toUpdate);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
public IActionResult Delete(int id)
{
string roleNameLoged = HttpContext.User.Claims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role).Value;
if (roleNameLoged.Equals("Moderator"))
{
UserGetModel userToDelete = userService.GetById(id);
if (UserRole.Admin.Equals("Admin"))
{
return(Forbid("You don`t have the right role for this action!"));
}
}
var result = userService.Delete(id);
if (result == null)
{
return(NotFound("User with the given id is not found !"));
}
return(Ok(result));
}
public IActionResult Delete(int id)
{
User curentUserLogIn = userService.GetCurentUser(HttpContext);
if (curentUserLogIn.UserRole == UserRole.UserManager)
{
UserGetModel userToDelete = userService.GetById(id);
if (userToDelete.UserRole.Equals(UserRole.Admin))
{
return(NotFound("Nu ai Rolul necear pentru aceaata operatie !"));
}
}
var result = userService.Delete(id);
if (result == null)
{
return(NotFound("User with the given id not fount !"));
}
return(Ok(result));
}
public async Task <IHttpActionResult> Get([FromUri] UserGetModel requestModel)
{
//do we have valid values?
if (requestModel.Page <= 0)
{
requestModel.Page = 1;
}
//do the needful
var users = await _userService.GetAsync(x =>
(!string.IsNullOrEmpty(requestModel.SearchText) &&
(x.FirstName.StartsWith(requestModel.SearchText) ||
x.LastName.StartsWith(requestModel.SearchText) ||
x.Email == requestModel.SearchText)) || true, null, true, requestModel.Page, requestModel.Count);
var model = users.ToList().Select(user => user.ToModel(_mediaService, _mediaSettings, _followService, _friendService));
return(RespondSuccess(new {
Users = model
}));
}
public IActionResult Put(int id, [FromBody] UserPostModel userPostModel)
{
User curentUserLogIn = userService.GetCurentUser(HttpContext);
if (curentUserLogIn.UserRole == UserRole.UserManager)
{
UserGetModel userToUpdate = userService.GetById(id);
var anulUserRegistered = curentUserLogIn.DataRegistered; //data inregistrarii
var curentMonth = DateTime.Now; //data curenta
var nrLuni = curentMonth.Subtract(anulUserRegistered).Days / (365.25 / 12); //diferenta in luni dintre datele transmise
if (nrLuni >= 6)
{
var result3 = userService.Upsert(id, userPostModel);
return(Ok(result3));
}
UserPostModel newUserPost = new UserPostModel
{
FirstName = userPostModel.FirstName,
LastName = userPostModel.LastName,
Username = userPostModel.Username,
Email = userPostModel.Email,
Password = userPostModel.Password,
UserRole = userToUpdate.UserRole.ToString()
};
var result2 = userService.Upsert(id, newUserPost);
return(Ok(result2));
}
var result = userService.Upsert(id, userPostModel);
return(Ok(result));
}
public IActionResult Delete(int id)
{
string roleNameLoged = HttpContext.User.Claims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role).Value;
if (roleNameLoged.Equals("UserManager"))
{
UserGetModel userToDelete = userService.GetById(id);
string activRoleName = userUserRolesService.GetUserRoleNameById(userToDelete.Id);
if (activRoleName.Equals("Admin"))
{
return(Forbid("Nu ai Rolul necear pentru aceasta operatie !"));
}
}
var result = userService.Delete(id);
if (result == null)
{
return(NotFound("User with the given id not fount !"));
}
return(Ok(result));
}
public UserGetModel Upsert(int id, UserPostModel user, User userLogat)
{
var existing = context
.Users
.Include(x => x.HistoryUserRole)
.ThenInclude(x => x.UserRole)
.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
return(null);
}
if (existing.Username.Equals(userLogat.Username))
{
return(null);
}
string existingCurrentRole = getLatestHistoryUserRole(existing.HistoryUserRole).UserRole.Name;
string addedByCurrentRole = getLatestHistoryUserRole(userLogat.HistoryUserRole).UserRole.Name;
HistoryUserRole currentHistory = getLatestHistoryUserRole(existing.HistoryUserRole);
if (existing == null)
{
//dbcontext.Users.(UserPostModel.ToUser(user));
//dbcontext.SaveChanges();
//return UserGetModel.FromUser(UserPostModel.ToUser(user));
User toReturn = Create(user);
return(UserGetModel.FromUser(toReturn));
}
User toUpdate = UserPostModel.ToUser(user);
toUpdate.Password = existing.Password;
toUpdate.DateRegister = existing.DateRegister;
toUpdate.Id = id;
if (addedByCurrentRole.Equals(RoleConstants.MODERATOR))
{
// https://www.aspforums.net/Threads/289493/Get-Number-of-months-between-two-dates-in-C/
var dateRegister = userLogat.DateRegister;
var dateCurrent = DateTime.Now;
int months = dateCurrent.Subtract(dateRegister).Days / 30;
// toAdd.Id = id;
if (months >= 6)
{
//dbcontext.Users.Update(toAdd);
//dbcontext.SaveChanges();
//return UserGetModel.FromUser(toAdd);
toUpdate.HistoryUserRole = existing.HistoryUserRole;
context.Users.Update(toUpdate);
context.SaveChanges();
context.Users.Attach(toUpdate);
if (existingCurrentRole != user.UserRole)
{
IEnumerable <UserRole> allRoles = context.UserRoles;
List <String> list = new List <string>();
foreach (UserRole userRole in allRoles)
{
list.Add(userRole.Name);
}
if (list.Contains(user.UserRole))
{
UserRole userRole = searchForRoleByTitle(user.UserRole);
HistoryUserRole history = new HistoryUserRole
{
UserRole = userRole,
StartTime = DateTime.Now
};
currentHistory.EndTime = DateTime.Now;
context.UserRoles.Attach(userRole);
toUpdate.HistoryUserRole.Add(history);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
return(null);
}
return(null);
// dbcontext.Users.Update(toAdd);
//dbcontext.SaveChanges();
//return toAdd;
}
return(null);
}
if (addedByCurrentRole.Equals(RoleConstants.ADMIN))
{
//toAdd.Id = id;
//dbcontext.Users.Update(toAdd);
//dbcontext.SaveChanges();
//return UserGetModel.FromUser(toAdd);
toUpdate.HistoryUserRole = existing.HistoryUserRole;
context.Users.Update(toUpdate);
context.SaveChanges();
context.Users.Attach(toUpdate);
if (existingCurrentRole != user.UserRole)
{
IEnumerable <UserRole> allRoles = context.UserRoles;
List <String> list = new List <string>();
foreach (UserRole userRole in allRoles)
{
list.Add(userRole.Name);
}
if (list.Contains(user.UserRole))
{
UserRole userRole = searchForRoleByTitle(user.UserRole);
HistoryUserRole history = new HistoryUserRole
{
UserRole = userRole,
StartTime = DateTime.Now
};
currentHistory.EndTime = DateTime.Now;
context.UserRoles.Attach(userRole);
toUpdate.HistoryUserRole.Add(history);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
return(null);
}
return(null);
}
return(null);
}
//IMPLEMENTARE CRUD PENTRU USER
public IEnumerable <UserGetModel> GetAll()
{
return(context.Users.Select(user => UserGetModel.FromUser(user)));
}
public void Upsert()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Upsert))
.Options;
using (var context = new UsersDbContext(options))
{
var usersService = new UserService(context, config);
var defaultuserRole = new UserRole
{
Name = RoleConstants.REGULAR
};
context.UserRoles.Add(defaultuserRole);
context.Entry(defaultuserRole).State = EntityState.Detached;
var defaultuserRole2 = new UserRole
{
Name = RoleConstants.ADMIN
};
context.UserRoles.Add(defaultuserRole2);
context.Entry(defaultuserRole2).State = EntityState.Detached;
UserRole userRoleRegular = new UserRole
{
Name = RoleConstants.REGULAR
};
HistoryUserRole historyRegular = new HistoryUserRole
{
UserRole = userRoleRegular,
};
List <HistoryUserRole> listRegular = new List <HistoryUserRole>
{
historyRegular
};
User radu69 = new User
{
Username = "******",
HistoryUserRole = listRegular,
DateRegister = DateTime.Now,
Password = "******",
Email = "*****@*****.**",
FirstName = "radu",
LastName = "radu"
};
context.Users.Add(radu69);
context.SaveChanges();
}
using (var context = new UsersDbContext(options))
{
var usersService = new UserService(context, config);
var defaultuserRole = new UserRole
{
Name = RoleConstants.ADMIN
};
context.UserRoles.Add(defaultuserRole);
context.SaveChanges();
context.Entry(defaultuserRole).State = EntityState.Detached;
UserRole userRole = new UserRole
{
Name = RoleConstants.ADMIN
};
HistoryUserRole history = new HistoryUserRole
{
UserRole = userRole,
};
List <HistoryUserRole> list = new List <HistoryUserRole>
{
history
};
User user2 = new User
{
Username = "******",
HistoryUserRole = list,
DateRegister = DateTime.Now,
Password = "******",
Email = "*****@*****.**",
FirstName = "cristina",
LastName = "cristina"
};
User firstAdded = new User
{
Username = "******",
DateRegister = DateTime.Now,
Password = "******",
Email = "*****@*****.**",
FirstName = "radu",
LastName = "radu"
};
var toUpdateWith = new UserPostModel
{
FirstName = "Gimli",
LastName = "Axeman",
UserName = "******",
Email = "*****@*****.**",
Password = "******",
UserRole = RoleConstants.ADMIN
};
var result = context.ChangeTracker.Entries()
.Where(t => t.State == EntityState.Unchanged);
UserGetModel lalala = usersService.Upsert(1, toUpdateWith, user2);
Assert.AreNotEqual(lalala.Username, firstAdded.Username);
Assert.AreNotEqual(lalala.Email, firstAdded.Email);
Assert.AreNotEqual(lalala.UserRole, RoleConstants.ADMIN);
}
}
public IEnumerable <UserGetModel> GetUsers()
{
var result = _dbContext.Users.ToList();
return(result.Select(u => UserGetModel.GetUserModel(u, _dbContext)));
}
