public async Task <IActionResult> PutCurrency(Guid id, Currency currency)
{
if (id != currency.Id)
{
return(BadRequest());
}
_context.Entry(currency).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CurrencyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutOperationMovement(Guid id, OperationMovement operationMovement)
{
if (id != operationMovement.Id)
{
return(BadRequest());
}
_context.Entry(operationMovement).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OperationMovementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutExpense(long id, Expense expense)
{
if (id != expense.Id)
{
return(BadRequest());
}
_context.Entry(expense).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpenseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void DeleteShouldDeleteUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userService = new UserService(context, null, config);
var newUser = new RegisterUserPostDto
{
Email = "*****@*****.**",
FullName = "dana",
Password = "******",
Username = "******"
};
userService.Register(newUser);
User addedUser = context.Users.Last();
context.Entry(addedUser).State = EntityState.Detached;
//var addedUser = context.Users.Where(u => u.Username == "alina3").FirstOrDefault();
userService.Delete(addedUser.Id, User);
int users = userService.GetAll().Count();
Assert.Zero(users);
}
}
public async Task <IHttpActionResult> PutExpenses(long id, Expenses expenses)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != expenses.Id)
{
return(BadRequest());
}
db.Entry(expenses).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpensesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutInstitutionBranch(Guid id, InstitutionBranch institutionBranch)
{
if (id != institutionBranch.Id)
{
return(BadRequest());
}
_context.Entry(institutionBranch).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstitutionBranchExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Upsert()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Upsert))
.Options;
using (var context = new ExpensesDbContext(options))
{
var roleService = new UserRoleService(context, config);
var toAdd = new UserRolePostDto
{
Name = "GOD"
};
var toUpdate = new UserRolePostDto
{
Name = "Sclave Master"
};
UserRole role = roleService.Create(toAdd);
context.Entry(role).State = EntityState.Detached;
UserRole updated = roleService.Upsert(role.Id, toUpdate);
Assert.AreNotEqual(role.Name, updated.Name);
}
}
public void UpdateExistingExpense()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpdateExistingExpense))
.Options;
using (var context = new ExpensesDbContext(options))
{
var expenseService = new ExpenseService(context);
var resultPostExpenseDto = new Lab2.DTOs.PostExpenseDto
{
Description = "Read3",
Sum = 3,
Location = "Read3",
Date = DateTime.Now,
Currency = "ADF",
Type = "FOOD",
Comments = null
};
var user = new User
{
FullName = "Baggings",
Email = "*****@*****.**",
Username = "******",
Password = "******",
CreatedAt = DateTime.Now
};
var lalala = expenseService.Create(resultPostExpenseDto, user);
List <Comment> comments = new List <Comment>();
Comment comment = new Comment
{
Id = 1,
Text = "One Ring to Rule them All",
Important = true
};
comments.Add(comment);
var dateDeadline = DateTime.Now.AddDays(20);
var resultExpense = new Expense
{
Description = "Read4",
Sum = 3,
Location = "Read4",
Date = DateTime.Now,
Currency = "ADF",
Comments = null
};
context.Entry(lalala).State = EntityState.Detached;
Assert.AreEqual(resultExpense.Location, "Read4");
Assert.AreEqual(resultExpense.Description, "Read4");
Assert.AreEqual(resultExpense.Currency, "ADF");
Assert.AreEqual(resultExpense.Comments, null);
}
}
public void UpdateTest1()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpdateTest1))
.Options;
using (var context = new ExpensesDbContext(options))
{
var expenseService = new ExpenseService(context);
var addedExpense = expenseService.Create(new Lab2Expense.ViewModels.ExpensePostModel
{
Description = "lksajdaksld",
Sum = 1.23,
Location = "sjdasjldls",
Date = new DateTime(),
Currency = "euro",
ExpenseType = "food",
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "asd",
Owner = null
}
},
}, null);
context.Entry(addedExpense).State = EntityState.Detached;
//context.SaveChanges();
var addedExpenseForUpdate = new Expense
{
Description = "update",
Sum = 1.23,
Location = "update",
Date = new DateTime(),
Currency = "euro",
ExpenseType = ExpenseType.food,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "asd",
Owner = null
}
},
Owner = null
};
var updateResult = expenseService.Upsert(addedExpense.Id, addedExpenseForUpdate);
var updateResultNull = expenseService.Upsert(2, addedExpenseForUpdate);
//Assert.IsNull(updateResultNull);
}
}
public int EditItem(Data.Models.Expenses model)
{
// find the record to update
var entityToUpdate = _db.Expenses.Find(model.Id);
if (entityToUpdate != null)
{
//set the new values
_db.Entry(entityToUpdate).CurrentValues.SetValues(model);
return(_db.SaveChanges());
}
return(0);
}
public CommonTest()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseLazyLoadingProxies()
.UseSqlite("DataSource=:memory:")
.Options;
db = new ExpensesDbContext(options);
db.Database.OpenConnection();
db.Database.EnsureCreated();
var system = db.Systems.First();
InitializeVariables(system);
FillData(db);
db.Entry(db.Users.Find(SocialDomainAdminId)).Collection(x => x.Domains).Load();
}
public IHttpActionResult DeleteExpenses(int id)
{
//if (!ModelState.IsValid) return BadRequest();
try
{
using (ExpensesDbContext db = new ExpensesDbContext())
{
var exp = db.Expenses.Where(e => e.Id == id).SingleOrDefault();
db.Entry(exp).State = EntityState.Deleted;
db.SaveChanges();
return(Ok());
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
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 ValidUpsert1()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsert1))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
UserRoleService userRoleService = new UserRoleService(context);
var added = new Lab2Expense.ViewModels.UserRolePostModel
{
Name = "Regular",
Description = "jskds"
};
var addedForUpdate = new Lab2Expense.ViewModels.UserRolePostModel
{
Name = "Admin",
Description = "smands"
};
var addedForUpdate2 = new Lab2Expense.Models.UserRole
{
Name = "UserManager",
Description = "smands"
};
var result = userRoleService.Create(added);
context.Entry(result).State = EntityState.Detached;
added.Name = "Admin";
var resultUpsert = userRoleService.Upsert(result.Id, added);
var resultNull = userRoleService.Upsert(8, added);
Assert.AreEqual("Admin", resultNull.Name);
Assert.AreEqual("Admin", resultUpsert.Name);
}
}
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 virtual void Update(TEntity entityToUpdate)
{
dbSet.Attach(entityToUpdate);
_context.Entry(entityToUpdate).State = EntityState.Modified;
}