public IHttpActionResult PostExpenses(Expense exp)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
using (ExpensesDbContext db = new ExpensesDbContext())
{
db.Entry(exp).State = (exp.Id == 0) ? EntityState.Added : EntityState.Modified;
db.SaveChanges();
return(Ok());
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void GetCurrentUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurrentUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var registerValidator = new RegisterValidator();
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registerValidator, config, user_userRoleService);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var resultAdded = usersService.Register(added);
var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var user = context.User_UserRoles.FirstOrDefault(user_userRole => user_userRole.EndTime == null);
Assert.IsNotNull(user);
//var currentUserRole = usersService.GetCurrentUserRole();
//Assert.AreEqual("Regular", currentUserRole.Name);
}
}
//inregistrare user
public UserGetModel Register(RegisterPostModel registerInfo)
{
//verificare username unique
User existing = context
.Users
.FirstOrDefault(u => u.Username == registerInfo.Username);
if (existing != null)
{
return(null);
}
context.Users.Add(new User
{
Email = registerInfo.Email,
LastName = registerInfo.LastName,
FirstName = registerInfo.FirstName,
Password = ComputeSha256Hash(registerInfo.Password),
Username = registerInfo.Username
});
context.SaveChanges();
return(Authenticate(registerInfo.Username, registerInfo.Password));
}
public Expense Create(Expense expense)
{
context.Expenses.Add(expense);
context.SaveChanges();
return(expense);
}
public GetUserDto Register(RegisterUserPostDto registerInfo)
{
User existing = context.Users.FirstOrDefault(u => u.Username == registerInfo.Username);
if (existing != null)
{
return(null);
}
context.Users.Add(new User
{
FullName = registerInfo.FullName,
Email = registerInfo.Email,
Username = registerInfo.Username,
Password = ComputeSha256Hash(registerInfo.Password),
UserRole = UserRole.Regular,
CreatedAt = DateTime.Now
});
context.SaveChanges();
return(Authenticate(registerInfo.Username, registerInfo.Password));
}
public void Post([FromBody] Expense expense)
{
context.Expenses.Add(expense);
context.SaveChanges();
}
public void CreateShouldAddTheUserUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddTheUserUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new UserRoleValidator();
var userUserRolesService = new UserUserRoleService(validator, context);
User userToAdd = new User
{
Email = "*****@*****.**",
LastName = "John",
FirstName = "Kennedy",
Password = "******",
CreatedAt = DateTime.Now,
UserUserRoles = new List <UserUserRole>()
};
context.Users.Add(userToAdd);
UserRole addUserRoleRegular = new UserRole
{
Name = "RegularTest",
Description = "Regular - Created for testing"
};
UserRole addUserRoleAdmin = new UserRole
{
Name = "AdminTest",
Description = "Admin - Created for testing"
};
context.UserRoles.Add(addUserRoleRegular);
context.UserRoles.Add(addUserRoleAdmin);
context.SaveChanges();
context.UserUserRoles.Add(new UserUserRole
{
User = userToAdd,
UserRole = addUserRoleRegular,
StartTime = DateTime.Parse("2019-06-10T00:00:00"),
EndTime = null
});
context.SaveChanges();
//sectiunea de schimbare valori invalidata de catre UserRoleValidator
var uurpost = new UserUserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "Admin"
};
var result = userUserRolesService.Create(uurpost);
Assert.IsNotNull(result); //User role nu exista in baza de date dupa validare, ==> exista erori la validare
//sectiunea de schimbare valori validata de catre UserRoleValidator
var uurpm1 = new UserUserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "AdminTest"
};
var result1 = userUserRolesService.Create(uurpm1);
Assert.IsNull(result1); //User role exista si se face upsert
}
}
public GetUserDto Register(RegisterUserPostDto register)
{
User existing = context.Users.FirstOrDefault(u => u.Username == register.Username);
if (existing != null)
{
return(null);
}
User user = new User
{
Email = register.Email,
FullName = register.FullName,
Password = ComputeSha256Hash(register.Password),
Username = register.Username,
CreatedAt = DateTime.Now
};
context.Users.Add(user);
context.SaveChanges();
context.Users.Attach(user);
UserRole role = new UserRole
{
Id = 1,
Name = RoleConstants.REGULAR
};
UserUserRole history = new UserUserRole
{
UserRole = role,
StartTime = DateTime.Now
};
List <UserUserRole> list = new List <UserUserRole>
{
history
};
context.UserRoles.Add(role);
context.UserRoles.Attach(role);
user.UserUserRoles = list;
context.SaveChanges();
return(Authenticate(register.Username, register.Password));
}
public ErrorsCollection Create(UserUserRolePostModel userUserRolePostModel)
{
var errors = userRoleValidator.Validate(userUserRolePostModel, context);
if (errors != null)
{
return(errors);
}
User user = context
.Users
.FirstOrDefault(u => u.Id == userUserRolePostModel.UserId);
if (user != null)
{
UserRole userRole = context
.UserRoles
.Include(urole => urole.UserUserRoles)
.FirstOrDefault(urole => urole.Name == userUserRolePostModel.UserRoleName);
UserUserRole currentUserUserRole = context
.UserUserRoles
.Include(uurole => uurole.UserRole)
.FirstOrDefault(uurole => uurole.UserId == user.Id && uurole.EndTime == null);
if (currentUserUserRole == null)
{
context.UserUserRoles.Add(new UserUserRole
{
User = user,
UserRole = userRole,
StartTime = DateTime.Now,
EndTime = null
});
context.SaveChanges();
return(null);
}
if (!currentUserUserRole.UserRole.Name.Contains(userUserRolePostModel.UserRoleName))
{
currentUserUserRole.EndTime = DateTime.Now;
context.UserUserRoles.Add(new UserUserRole
{
User = user,
UserRole = userRole,
StartTime = DateTime.Now,
EndTime = null
});
context.SaveChanges();
return(null);
}
else
{
return(null);
}
}
return(null);
}
public void ValidUpsert()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsert))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, config);
var userRoleService = new UserRoleService(context);
var addedRole = new UserRolePostModel
{
Name = "Admin",
Description = "jskds"
};
var result = userRoleService.Create(addedRole);
var addedRole2 = new UserRolePostModel
{
Name = "Regular",
Description = "jskds"
};
var resultRegular = userRoleService.Create(addedRole2);
var added = new Lab2Expense.Models.User
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
var adminRole = context
.UserRole
.FirstOrDefault(ur => ur.Name == "Admin");
context.Users.Add(added);
context.UserUserRole.Add(new UserUserRole
{
User = added,
UserRole = adminRole,
StartTime = DateTime.Now,
EndTime = null,
});
var addedRegular = new Lab2Expense.Models.User
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
var RegularRole = context
.UserRole
.FirstOrDefault(ur => ur.Name == "Regular");
context.Users.Add(addedRegular);
context.UserUserRole.Add(new UserUserRole
{
User = addedRegular,
UserRole = RegularRole,
StartTime = DateTime.Now,
EndTime = null,
});
context.SaveChanges();
context.Entry(added).State = EntityState.Detached;
context.Entry(adminRole).State = EntityState.Detached;
context.Entry(addedRegular).State = EntityState.Detached;
var addedRegular2 = new Lab2Expense.Models.User
{
Email = "*****@*****.**",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
context.Entry(addedRegular2).State = EntityState.Detached;
// var resultAdded = usersService.Register(added);
// var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var resultUpdate = usersService.Upsert(addedRegular.Id, addedRegular2, added);
Assert.AreEqual("*****@*****.**", addedRegular.Email);
}
}
public int Complete()
{
return(_context.SaveChanges());
}
public void CreateShouldAddTheUserUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddTheUserUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new UserRoleValidator();
var userUserRolesService = new User_UserRoleService(validator, context);
User userToAdd = new User
{
Email = "*****@*****.**",
LastName = "Ion",
FirstName = "POpescu",
Password = "******",
DataRegistered = DateTime.Now,
User_UserRoles = new List <User_UserRole>()
};
context.Users.Add(userToAdd);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
UserRole addUserRoleAdmin = new UserRole
{
Name = "AdminDeTest",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.UserRoles.Add(addUserRoleAdmin);
context.SaveChanges();
context.User_UserRoles.Add(new User_UserRole
{
User = userToAdd,
UserRole = addUserRoleRegular,
StartTime = DateTime.Parse("2019-06-13T00:00:00"),
EndTime = null
});
context.SaveChanges();
var u_urpm = new User_UserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "Admin"
};
var result1 = userUserRolesService.Create(u_urpm);
Assert.IsNotNull(result1); //User role nu exista in baza de date dupa validare, ==> exista erori la validare
var u_urpm1 = new User_UserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "AdminDeTest"
};
var result2 = userUserRolesService.Create(u_urpm1);
Assert.IsNull(result2); //User role exista si se face upsert
}
}