public void AddNewsWhenNewsIsAddedToDbShouldReturnNews()
{
//Arange -> prepare the objects
var repo = new Repository<Models.News>(new NewsContext());
var news = new Models.News()
{
Id = 1,
Title = "title 1",
Content = "content 1",
PublishedData = DateTime.Now
};
//Act -> perform some logic
repo.Add(news);
repo.SaveChanges();
//Assert -> validate the results
var newsFromDb = repo.GetById(news.Id);
Assert.IsNotNull(newsFromDb);
Assert.AreEqual(news.Title, newsFromDb.Title);
Assert.AreEqual(news.Content, newsFromDb.Content);
Assert.AreEqual(news.PublishedData, newsFromDb.PublishedData);
Assert.IsTrue(newsFromDb.Id != 0);
}
private IEnumerable<EmployeeLogin> SRVCUpdateLogins(Helpers.Log.SessionInfo logSession, Repository.Logic.Repository rep,
long employeeId, IEnumerable<string> addLogins, IEnumerable<string> removeLogins)
{
#pragma warning disable 618
logSession.Add($"Try to get employee with id = {employeeId}");
var emp = rep.Get<Repository.Model.Employee>(e => e.EmployeeId == employeeId, false, new string[] { "Logins" }).FirstOrDefault();
if (emp == null)
throw new Exception(string.Format(Properties.Resources.STUFFINGSERVICE_EmployeeNotFound, employeeId));
var existedLogins = emp.Logins.Select(r => r.DomainLogin);
#region Add logins
if (addLogins != null && addLogins.Any())
{
logSession.Add($"Add logins...");
var addLoginsUpper = addLogins
.Except(existedLogins)
.ToArray()
.Select(r => rep.New<Repository.Model.EmployeeLogin>((er) =>
{
er.EmployeeLoginId = emp.EmployeeId;
er.DomainLogin = r;
}))
.ToArray();
logSession.Add($"Add this logins {addLoginsUpper.Concat(r => r.DomainLogin, ",")} for employee id = {employeeId}");
foreach (var r in addLoginsUpper)
emp.Logins.Add(r);
rep.AddRange(addLoginsUpper, saveAfterInsert: false);
}
#endregion
#region Remove rights
if (removeLogins != null && removeLogins.Any())
{
logSession.Add($"Remove logins...");
var removeLoginsUpper = removeLogins
.Intersect(existedLogins)
.ToArray()
.Join(emp.Logins, r => r, er => er.DomainLogin.ToUpper(), (r, er) => er)
.ToArray();
logSession.Add($"Remove this logins {removeLoginsUpper.Concat(r => r.DomainLogin, ",")} for employee id = {employeeId}");
foreach (var r in removeLoginsUpper)
emp.Logins.Remove(r);
rep.RemoveRange(removeLoginsUpper, saveAfterRemove: false);
}
#endregion
rep.SaveChanges();
return emp.Logins.Select(er => AutoMapper.Mapper.Map<EmployeeLogin>(er));
#pragma warning restore 618
}
//redundant
//public List<Accounts>AccountsList { get; set; }
public void Create(Tweets persistObject)
{
using (Repository<Tweets> DataAccessHelper = new Repository<Tweets>())
{
DataAccessHelper.Add(persistObject);
DataAccessHelper.SaveChanges();
}
}
public void SaveObject(Tweets tweet)
{
using (Repository<Tweets> DataAccessHelper = new Repository<Tweets>())
{
DataAccessHelper.Add(tweet);
DataAccessHelper.SaveChanges();
}
}
public void AddNewProduct()
{
using (var dataAccessHelper = new Repository<Product>())
{
dataAccessHelper.Add(this);
dataAccessHelper.SaveChanges();
}
}
//===============================================================
public static void BatchInsertAndRemove(Repository<TestClass> repo)
{
var testObjects = Enumerable.Range(0, 5).Select(x => new TestClass(x.ToString(), x.ToString())).ToList();
repo.RemoveAll(repo.Items);
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
repo.Insert(testObjects);
repo.SaveChanges();
Assert.IsTrue(repo.Items.Any());
Assert.IsTrue(repo.Items.ToList().All(x => testObjects.Exists(y => y.ID == x.ID)));
// Remove all batch
repo.RemoveAll();
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
// Remove all without saving in between
repo.Insert(testObjects);
repo.RemoveAll();
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
// Remove all with inserts before and after
repo.Insert(testObjects);
repo.RemoveAll();
repo.Insert(testObjects);
repo.RemoveAll();
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
repo.Insert(testObjects);
repo.SaveChanges();
// Remove all by key
repo.RemoveAllByKey(repo.Items.ToList().Select(x => new object[] { x.ID }));
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
// Remove all by object
repo.Insert(testObjects);
repo.SaveChanges();
repo.RemoveAll(testObjects);
repo.SaveChanges();
Assert.IsTrue(!repo.Items.Any());
}
public ActionResult Here(int locationId)
{
// Get the data
IRepository repository = new Repository(new CheckInDatabaseContext());
var location = repository.GetById<Location>(locationId);
if (location == null)
{
return new HttpNotFoundResult();
}
var username = HttpContext.User.Identity.Name;
var user = repository.Query<ApplicationUser>().SingleOrDefault(u => u.UserName == username);
if (user == null)
{
return new HttpNotFoundResult();
}
// make a new check in
var checkIn = new CheckIn();
checkIn.User = user;
checkIn.Location = location;
checkIn.Time = DateTime.Now;
repository.Insert(checkIn);
// check to see if this user meets any achievements
var allCheckins = repository.Query<CheckIn>().Where(c => c.User.Id == user.Id);
var allAchievements = repository.Query<Achievement>();
var allLocationIds = repository.Query<Location>().Select(l => l.Id);
// two in one day?
if (!allAchievements.Any(a => a.Type == AchievementType.TwoInOneDay) && allCheckins.Count(c => EntityFunctions.TruncateTime(c.Time) == DateTime.Today) > 2)
{
var twoInOneDay = new Achievement { Type = AchievementType.TwoInOneDay, User = user, TimeAwarded = DateTime.Now };
repository.Insert(twoInOneDay);
}
// all locations?
var hasAll = false;
foreach (var testLocationId in allLocationIds)
{
hasAll = hasAll || allCheckins.Any(c => c.Location.Id == testLocationId);
}
if (!allAchievements.Any(a => a.Type == AchievementType.AllLocations) && hasAll)
{
var allLocations = new Achievement { Type = AchievementType.AllLocations, User = user, TimeAwarded = DateTime.Now };
repository.Insert(allLocations);
}
// some day we'll have hundreds of achievements!
repository.SaveChanges();
return RedirectToAction("Index");
}
public void AddNews_InValidNewsAddedToDb_ShouldThrowException()
{
// Arrange -> prapare the objects
var newInvalidNews = new News { Title = "Invalid", Content = "Something", PublishDate = DateTime.Now };
IRepository<News> repository = new Repository<News>();
// Act -> perform some logic
repository.Add(newInvalidNews);
repository.SaveChanges();
}
public ActionResult DeleteFile(Guid id)
{
using (Repository r = new Repository())
{
FileUploadEntity f = r.Files.FirstOrDefault(x => x.ID == id);
if (f != null)
{
r.Files.Remove(f);
r.SaveChanges();
}
}
return RedirectToAction("Gallery");
}
private void SaveToDB(TransitionAction[] transiton_actions,
PointDialogAction[] point_actions)
{
int userId = Int32.Parse(Request.Cookies["UserId"]);
var save = db.SavedGames.FirstOrDefault(i => i.GameId == Point.GameId &&
i.UserId == userId);
string key = FillingKey(save.Keys, transiton_actions, point_actions);
save.Keys = key;
save.State = Point.StateNumber;
db.Attach(save).State = EntityState.Modified;
db.SaveChanges();
}
public static void DeleteProfile(User user)
{
foreach (var evaluation in Repository.Filter <BookEvaluation>(e => e.User.Contains(user)))
{
evaluation.Delete();
}
foreach (var evaluation in Repository.Filter <FilmEvaluation>(e => e.User.Contains(user)))
{
evaluation.Delete();
}
foreach (var evaluation in Repository.Filter <SerialEvaluation>(e => e.User.Contains(user)))
{
evaluation.Delete();
}
foreach (var review in Repository.Filter <BookReview>(e => e.User.Contains(user)))
{
review.Delete();
}
foreach (var review in Repository.Filter <FilmReview>(e => e.User.Contains(user)))
{
review.Delete();
}
foreach (var review in Repository.Filter <SerialReview>(e => e.User.Contains(user)))
{
review.Delete();
}
foreach (var comment in Repository.Filter <Comment>(e => e.User.Contains(user)))
{
comment.Delete();
}
foreach (var selection in Repository.Filter <Selection>(e => e.User.Contains(user)))
{
selection.Delete();
}
foreach (var image in user.Images)
{
image.Delete();
}
foreach (var privacy in user.Privacy)
{
privacy.Delete();
}
user.Delete();
Repository.SaveChanges();
}
public void Handle(AppClaimAdded @event)
{
var repository = new Repository <ApplicationClaim>(this.dbContext);
var appClaim = new ApplicationClaim()
{
AppId = @event.AppId,
ClaimType = @event.ClaimType,
ClaimValue = @event.ClaimValue
};
repository.Save(appClaim);
repository.SaveChanges();
}
public void Handle(UserAdminClaimAdded @event)
{
var repository = new Repository <UserClaim>(this.dbContext);
var userClaim = new UserClaim()
{
Email = @event.Email,
ClaimType = @event.ClaimType,
ClaimValue = @event.ClaimValue
};
repository.Save(userClaim);
repository.SaveChanges();
}
public async Task <IActionResult> IndexBatchDetail(ProductlistBatchViewModel model)
{
if (ModelState.IsValid)
{
Repository.UpdateList(false, model.Products.Data, model.ModifiedProducts);
await Repository.SaveChanges();
return(RedirectToAction("IndexBatchDetail", new { page = model.Products.Page }));
}
else
{
return(View(model));
}
}
public ViewResult RsvpForm(GuestResponse guestResponse)
{
if (ModelState.IsValid)
{
_dbContext.GuestResponses.Add(guestResponse);
_dbContext.SaveChanges();
return(View("Thanks", guestResponse));
}
else
{
// there is a validation error
return(View());
}
}
public ActionResult AlterarSenha(AlterarSenhaViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var identity = User.Identity as ClaimsIdentity;
var login = identity.Claims.FirstOrDefault(x => x.Type == "Login").Value;
var usuario = repository.Usuario.ObterPeloLogin(login);
if (Usuario.Encriptar(viewModel.SenhaAtual) != usuario.Senha)
{
TempData["Alerta"] = "Senha atual informada está incorreta";
return(View());
}
if (Usuario.Encriptar(viewModel.NovaSenha) == usuario.Senha)
{
TempData["Alerta"] = "Nova senha não poder ser a mesma que a senha atual";
return(View());
}
usuario.Senha = Usuario.Encriptar(viewModel.NovaSenha);
try
{
repository.SaveChanges();
TempData["SenhaAlterada"] = "Senha alterada com sucesso";
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
TempData["Alerta"] = ex.Message.Replace(Environment.NewLine, "</br>");
return(View());
}
}
public ActionResult Create(Pupil pupil, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
string[] AllowedExtensions = new[] { ".jpg", ".png", "jpeg" };
if (file.ContentLength > 0)
{
if (!AllowedExtensions.Contains(file.FileName.Substring(file.FileName.LastIndexOf('.'))))
{
//ModelState.AddModelError("Photo", "Please upload valid extensions(jpeg,jpg or png)");
TempData["Success"] = "Please upload valid photo types (eg jpeg ,jpg or png)";
return(RedirectToAction("Create"));
}
else
{
db.Pupils.Add(pupil);
pupil.ContentType = file.ContentType;
byte[] fileBytes = new byte[file.ContentLength];
file.InputStream.Read(fileBytes, 0, file.ContentLength);
pupil.Photo = fileBytes;
db.SaveChanges();
TempData["Success"] = "Record Added";
return(RedirectToAction("Index"));
}
}
if (file.ContentLength < 0)
{
TempData["Success"] = "Please select photo";
return(RedirectToAction("Create"));
}
}
return(View(pupil));
}
public ActionResult Create(IFormCollection collection)
//public ActionResult Create(PizzaForm p)
//public ActionResult Create(Pizza pizza)
{
try
{
//if (ModelState.IsValid)
//{
Pizza pizza = new Pizza()
{
//Id = int.Parse(collection["Id"]),
Name = collection["Name"],
Price = decimal.Parse(collection["Price"])
};
//Convert all ingredientsId to int
List <int> ingredientsIdList = new List <int>();
foreach (string ingredientsIdString in collection["ingredientsId"])
{
ingredientsIdList.Add(int.Parse(ingredientsIdString));
}
//Add all ingredients to pizza
foreach (int ingredientId in ingredientsIdList)
{
Ingredient ingredient = Mapper.Map <Ingredients, Ingredient>(IngredientsRepository.GetById(ingredientId));
pizza.addIngredients(ingredient);
}
Repository.Save(Mapper.Map <Pizza, Pizzas>(pizza));
Repository.SaveChanges();
//}
//else
//{
// return View();
//}
return(RedirectToAction(nameof(Index)));
}
catch (ArgumentException ex)
{
//ModelState.AddModelError("Stock", ex.Message);
return(View());
}
catch
{
return(View());
}
}
public void Accept()
{
using (var repo = new Repository())
{
if (_isToUpdate)
{
repo.Attach(Group);
if (Group.ScheduleRecords.Any((s) => s.Group.CorpusId != Corpus.CorpusId))
{
CustomMessageBox messageBox = new CustomMessageBox("Ошибка обновления отделения",
$"Группа имеет пары в расписании в отделении {Group.Corpus.CorpusName}");
messageBox.ShowDialog();
return;
}
}
repo.Attach(Spezialisation);
repo.Attach(Corpus);
if (Budget == "Бюджет")
{
Group.IsBudget = true;
}
else
{
Group.IsBudget = false;
}
if (_isToUpdate)
{
Group.Spezialisation = Spezialisation;
Group.Corpus = Corpus;
repo.Update(Group);
}
else
{
Group.Spezialisation = Spezialisation;
Group.Corpus = Corpus;
repo.Add(Group);
}
repo.SaveChanges();
Close();
}
}
public static ApprovalType UpdateApprovalType(ApprovalType approvalType)
{
try
{
using Repository <ApprovalType> repo = new Repository <ApprovalType>();
repo.ApprovalType.Update(approvalType);
if (repo.SaveChanges() > 0)
{
return(approvalType);
}
return(null);
}
catch { throw; }
}
public ActionResult Edit(EditNoteViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
notes.Update(model.Note);
notes.SaveChanges();
notes.Dispose();
return(RedirectToAction("Index"));
}
public static MatTranTypes UpdateMatTransType(MatTranTypes matTranTypes)
{
try
{
using Repository <MatTranTypes> repo = new Repository <MatTranTypes>();
repo.MatTranTypes.Update(matTranTypes);
if (repo.SaveChanges() > 0)
{
return(matTranTypes);
}
return(null);
}
catch { throw; }
}
public static CardType UpdateCardType(CardType cardType)
{
try
{
using Repository <CardType> repo = new Repository <CardType>();
repo.CardType.Update(cardType);
if (repo.SaveChanges() > 0)
{
return(cardType);
}
return(null);
}
catch { throw; }
}
public static Segment UpdateSegment(Segment segment)
{
try
{
using Repository <Segment> repo = new Repository <Segment>();
repo.Segment.Update(segment);
if (repo.SaveChanges() > 0)
{
return(segment);
}
return(null);
}
catch { throw; }
}
//===============================================================
public static void ChangeTracking(Repository <TestClass> repo)
{
var obj = new TestClass("myKey", "myValue");
repo.Insert(obj);
repo.SaveChanges();
var storedObj = repo.Find(obj.ID);
storedObj.Object.StringValue = "newValue";
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue", storedObj.Object.StringValue);
// Test Update function
repo.Update(new { StringValue = "newValue2" }, storedObj.Object.ID);
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue2", storedObj.Object.StringValue);
repo.RemoveAll();
repo.SaveChanges();
// Test changing enumerated objects
var objects = Enumerable.Range(0, 10).Select(x => new TestClass(x.ToString(), x.ToString()));
repo.Insert(objects);
repo.SaveChanges();
foreach (var item in repo.Items)
{
Assert.AreEqual(item.ID, item.StringValue);
}
foreach (var item in repo.Items)
{
item.StringValue = ((int.Parse(item.StringValue)) + 1).ToString();
}
repo.SaveChanges();
foreach (var item in repo.Items)
{
Assert.AreNotEqual(item.ID, item.StringValue);
}
repo.RemoveAll();
repo.SaveChanges();
}
public void AddNewsWhenNewsIsInvalidShouldThrowException()
{
//Arrange -> prepare the objects
var repo = new Repository<Models.News>(new NewsContext());
var invalidNews = new Models.News()
{
Content = null
};
//Act -> perform some logic
repo.Add(invalidNews);
repo.SaveChanges();
//Assert -> expect an exception
}
public static StructureCreation Update(StructureCreation structureCreation)
{
try
{
using Repository <StructureCreation> repo = new Repository <StructureCreation>();
repo.StructureCreation.Update(structureCreation);
if (repo.SaveChanges() > 0)
{
return(structureCreation);
}
return(null);
}
catch { throw; }
}
public static void UpdateCustomer(Customer customer)
{
var repository = new Repository();
var cust = repository.DataSet <Customer>().Where(x => x.Id == customer.Id).SingleOrDefault();
if (cust != null)
{
cust.FirstName = customer.FirstName;
cust.LastName = customer.LastName;
cust.Email = customer.Email;
cust.PhoneNo = customer.PhoneNo;
repository.Update(cust);
repository.SaveChanges();
}
}
public static AsignmentAcctoAccClass UpdateAccToAccClass(AsignmentAcctoAccClass assignAcctoAcc)
{
try
{
using Repository <AsignmentAcctoAccClass> repo = new Repository <AsignmentAcctoAccClass>();
repo.AsignmentAcctoAccClass.Update(assignAcctoAcc);
if (repo.SaveChanges() > 0)
{
return(assignAcctoAcc);
}
return(null);
}
catch { throw; }
}
public static TaxIntegration UpdateTaxIntegration(TaxIntegration taxintegration)
{
try
{
using Repository <TaxIntegration> repo = new Repository <TaxIntegration>();
repo.TaxIntegration.Update(taxintegration);
if (repo.SaveChanges() > 0)
{
return(taxintegration);
}
return(null);
}
catch { throw; }
}
public static AsignmentCashAccBranch UpdateCashAccToBranches(AsignmentCashAccBranch assignCashToBranch)
{
try
{
using Repository <AsignmentCashAccBranch> repo = new Repository <AsignmentCashAccBranch>();
repo.AsignmentCashAccBranch.Update(assignCashToBranch);
if (repo.SaveChanges() > 0)
{
return(assignCashToBranch);
}
return(null);
}
catch { throw; }
}
public static Glaccounts UpdateGLAccounts(Glaccounts glAccounts)
{
try
{
using Repository <Glaccounts> repo = new Repository <Glaccounts>();
repo.Glaccounts.Update(glAccounts);
if (repo.SaveChanges() > 0)
{
return(glAccounts);
}
return(null);
}
catch { throw; }
}
public static GlsubCode UpdateGLSubCode(GlsubCode glSubCode)
{
try
{
using Repository <GlsubCode> repo = new Repository <GlsubCode>();
repo.GlsubCode.Update(glSubCode);
if (repo.SaveChanges() > 0)
{
return(glSubCode);
}
return(null);
}
catch { throw; }
}
public override User Modify(User model)
{
User currentRole = Get(model.UserId);
UpdateRoles(currentRole, model);
if (!string.IsNullOrEmpty(model.Password))
{
model.Password = EncriptionUtils.HashValueToString(model.Password, model.IdentificationNumber);
}
Repository.Db.Entry(currentRole).CurrentValues.SetValues(model);
Repository.SaveChanges();
return(model);
}
public static GlaccUnderSubGroup UpdateUnderSubGroup(GlaccUnderSubGroup glUnderSubGroup)
{
try
{
using Repository <GlaccUnderSubGroup> repo = new Repository <GlaccUnderSubGroup>();
repo.GlaccUnderSubGroup.Update(glUnderSubGroup);
if (repo.SaveChanges() > 0)
{
return(glUnderSubGroup);
}
return(null);
}
catch { throw; }
}
public static CostCenters UpdateCostCenter(CostCenters costCenters)
{
try
{
using Repository <CostCenters> repo = new Repository <CostCenters>();
repo.CostCenters.Update(costCenters);
if (repo.SaveChanges() > 0)
{
return(costCenters);
}
return(null);
}
catch { throw; }
}
public TblStateWiseGst Update(TblStateWiseGst stateWiseGst)
{
try
{
using Repository <TblStateWiseGst> repo = new Repository <TblStateWiseGst>();
repo.TblStateWiseGst.Update(stateWiseGst);
if (repo.SaveChanges() > 0)
{
return(stateWiseGst);
}
return(null);
}
catch { throw; }
}
public static Ptmaster Update(Ptmaster ptMaster)
{
try
{
using Repository <Ptmaster> repo = new Repository <Ptmaster>();
repo.Ptmaster.Update(ptMaster);
if (repo.SaveChanges() > 0)
{
return(ptMaster);
}
return(null);
}
catch { throw; }
}
public static VoucherTypes UpdateVoucherType(VoucherTypes voucherTypes)
{
try
{
using Repository <VoucherTypes> repo = new Repository <VoucherTypes>();
repo.VoucherTypes.Update(voucherTypes);
if (repo.SaveChanges() > 0)
{
return(voucherTypes);
}
return(null);
}
catch { throw; }
}
public void AddEntityWorker()
{
using (var repo = new Repository())
{
// FileName is not nullable, make sure to specify it
// Primary Id cant be set for Image, This will be set automaticly. you cant specify the Id. EntityWorker will consider this as an update otherwise.
var tag = new Tag {
Filename = "test", Interpret = "TestInterpret", Title = "Title", Image = new Image {
Data = new byte[10]
}
};
repo.Save(tag);
repo.SaveChanges(); // Commit to the database
}
}
public void AddNews_ValidNewsAddedToDb_ShouldReturnNews()
{
// Arrange -> prapare the objects
var newValidNews = new News { Title = "Valid news added", Content = "Something", PublishDate = DateTime.Now };
IRepository<News> repository = new Repository<News>();
// Act -> perform some logic
repository.Add(newValidNews);
repository.SaveChanges();
// Assert -> validate the results
var newsFromDb = repository.Find(newValidNews.Id);
Assert.IsNotNull(newsFromDb);
Assert.AreEqual(newValidNews.Title, newsFromDb.Title);
Assert.AreEqual(newValidNews.Content, newsFromDb.Content);
Assert.AreEqual(newValidNews.PublishDate, newsFromDb.PublishDate);
Assert.IsTrue(newsFromDb.Id != 0);
}
public void ModifyNews_ValidNews_ShouldModifyNews()
{
// Arrange -> prapare the objects
IRepository<News> repository = new Repository<News>();
ClearDatabase(repository);
SeedNews(repository);
var newsFromDb = repository.All().FirstOrDefault();
string title = "Modified Title";
var content = "Modified Content";
var dateTimeNow = DateTime.Now;
// Act -> perform some logic
newsFromDb.Title = title;
newsFromDb.Content = content;
newsFromDb.PublishDate = dateTimeNow;
repository.SaveChanges();
// Assert -> validate the results
var modifiedNewsFromDb = repository.Find(newsFromDb.Id);
Assert.IsNotNull(modifiedNewsFromDb);
Assert.AreEqual(content, modifiedNewsFromDb.Content);
Assert.AreEqual(title, modifiedNewsFromDb.Title);
Assert.AreEqual(dateTimeNow.ToString(), modifiedNewsFromDb.PublishDate.ToString());
}
private void UpdateFile(string fileName, HttpPostedFileBase file)
{
var inputStream = file.InputStream;
FileUploadEntity fileEntity = new FileUploadEntity();
fileEntity.ID = Guid.NewGuid();
fileEntity.Name = Path.GetFileName(fileName);
fileEntity.ContentType = file.ContentType;
byte[] fileContents = new byte[file.ContentLength];
inputStream.Read(fileContents, 0, file.ContentLength);
fileEntity.FileContents = ResizeImage(fileContents, 400, 250);
using (Repository r = new Repository())
{
r.Files.Add(fileEntity);
r.SaveChanges();
}
}
private MenuVM SaveMenu(MenuVM vm, string menuType)
{
using (var r = new Repository())
{
foreach (var c in r.MenuCategories.Include("MenuItems").Where(c => c.CategoryType == menuType))
{
while (c.MenuItems.Any())
{
r.MenuItems.Remove(c.MenuItems.First());
}
r.MenuCategories.Remove(c);
}
foreach (var c in vm.Categories)
{
r.MenuCategories.Add(new MenuCategoryEntity()
{
Sequence = c.Sequence,
CategoryType = menuType,
Name = c.Name,
MenuItems = c.MenuItems.ConvertAll(i => new MenuItemEntity()
{
Sequence = i.Sequence,
Name = i.Name,
Description = i.Description,
Price = i.Price
})
});
}
r.SaveChanges();
}
return vm;
}
public void DeleteNews_ExistingNews_ShouldDeleteNews()
{
// Arrange -> prapare the objects
IRepository<News> repository = new Repository<News>();
ClearDatabase(repository);
SeedNews(repository);
var newsFromDb = repository.All().FirstOrDefault();
// Act -> perform some logic
repository.Delete(newsFromDb.Id);
repository.SaveChanges();
// Assert -> validate the results
var deletedNewsFromDb = repository.Find(newsFromDb.Id);
Assert.IsNull(deletedNewsFromDb);
}
public ActionResult StoreHours(StoreHoursVM vm)
{
using (var r = new Repository())
{
var entity = r.StoreHours.First();
entity.Line1 = vm.Line1;
entity.Line2 = vm.Line2;
entity.Line3 = vm.Line3;
r.SaveChanges();
}
return View(vm);
}
public async void Execute(IJobExecutionContext context)
{
using (var repo = new Repository())
{
var form = repo.GetForm(FormId).ConfigureAwait(false).GetAwaiter().GetResult();
if (form == null)
{
_log.Info($"Form {FormId} does not exist");
return;
}
_log.Info($"Blocking form {form.name}");
var formType = (FormType) form.form_type_id;
switch (formType)
{
case FormType.Edu:
case FormType.OtherEdu:
{
foreach (var edu in form.edu_kind.SelectMany(t => t.edus))
{
if (!edu.blocked_forms.Contains(form))
{
edu.blocked_forms.Add(form);
_log.Info($"Newly blocked form {form.name} for {edu.number_sysname}");
}
else
{
_log.Info($"Already blocked form {form.name} for {edu.number_sysname}");
}
}
}
break;
case FormType.Municipality:
case FormType.OtherMunicipality:
{
var munits = await repo.GetMunicipalities();
foreach (var munit in munits)
{
if (!munit.blocked_forms.Contains(form))
{
munit.blocked_forms.Add(form);
_log.Info($"Newly blocked form {form.name} for {munit.name}");
}
else
{
_log.Info($"Already blocked form {form.name} for {munit.name}");
}
}
}
break;
}
repo.SaveChanges();
}
_log.Info($"Blocked form {FormId}. Planned time {context.ScheduledFireTimeUtc} Executed at {context.FireTimeUtc}");
}
public void ModifyNews_WithInValidNews_ShouldThrowException()
{
// Arrange -> prapare the objects
IRepository<News> repository = new Repository<News>();
ClearDatabase(repository);
SeedNews(repository);
var newsFromDb = repository.All().FirstOrDefault();
string title = "";
var content = "Modified Content";
var dateTimeNow = DateTime.Now;
// Act -> perform some logic
newsFromDb.Title = title;
newsFromDb.Content = content;
newsFromDb.PublishDate = dateTimeNow;
repository.SaveChanges();
// Assert -> validate the results
}
//===============================================================
public static void ChangeTracking(Repository<TestClass> repo)
{
var obj = new TestClass("myKey", "myValue");
repo.Insert(obj);
repo.SaveChanges();
var storedObj = repo.Find(obj.ID);
storedObj.Object.StringValue = "newValue";
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue", storedObj.Object.StringValue);
// Test Update function
repo.Update(new { StringValue = "newValue2" }, storedObj.Object.ID);
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue2", storedObj.Object.StringValue);
repo.RemoveAll();
repo.SaveChanges();
// Test changing enumerated objects
var objects = Enumerable.Range(0, 10).Select(x => new TestClass(x.ToString(), x.ToString()));
repo.Insert(objects);
repo.SaveChanges();
foreach (var item in repo.Items)
Assert.AreEqual(item.ID, item.StringValue);
foreach (var item in repo.Items)
item.StringValue = ((int.Parse(item.StringValue)) + 1).ToString();
repo.SaveChanges();
foreach (var item in repo.Items)
Assert.AreNotEqual(item.ID, item.StringValue);
repo.RemoveAll();
repo.SaveChanges();
}
public void DeleteNews_NonExistingNews_ShouldThrowException()
{
// Arrange -> prapare the objects
IRepository<News> repository = new Repository<News>();
ClearDatabase(repository);
SeedNews(repository);
var newsFromDb = repository.Find(1000000);
// Act -> perform some logic
repository.Delete(newsFromDb);
repository.SaveChanges();
// Assert -> validate the results
}
//===============================================================
public static void TypedRepositoryTest(Repository<TestClass, String> repo)
{
repo.RemoveAll();
repo.SaveChanges();
var testObj = new TestClass("myKey", "myValue");
repo.Insert(testObj);
repo.SaveChanges();
var newObj = new TestClass { ID = testObj.ID, StringValue = "NEW VALUE" };
var dbObj = repo.Find(newObj.ID);
dbObj.Object.StringValue = newObj.StringValue;
repo.SaveChanges();
dbObj = repo.Find(newObj.ID);
Assert.AreEqual(newObj.StringValue, dbObj.Object.StringValue);
repo.RemoveAll();
}
//===============================================================
public static void Items(Repository<TestClass> repo)
{
var testObjects = Enumerable.Range(0, 10).Select(x => new TestClass(x.ToString(), x.ToString()));
repo.Insert(testObjects);
repo.SaveChanges();
var items = repo.Items.ToList().OrderBy(x => x.StringValue).ToList();
Assert.AreEqual(10, items.Count);
for (int i = 0; i < 10; ++i)
Assert.AreEqual(i.ToString(), items[i].StringValue);
repo.RemoveAll();
repo.SaveChanges();
Assert.AreEqual(0, repo.Items.Count());
}
//===============================================================
public static void InsertAndRemove(Repository<TestClass> testObjects)
{
var testObj = new TestClass("myKey", "myValue");
testObjects.Insert(testObj);
testObjects.SaveChanges();
var storedObj = testObjects.Find(testObj.ID);
Assert.NotNull(storedObj.Object);
Assert.AreEqual(testObj.ID, storedObj.Object.ID);
Assert.AreEqual(testObj.ID, storedObj.Object.ID);
testObjects.Remove(testObj);
testObjects.SaveChanges();
storedObj = testObjects.Find(testObj.ID);
Assert.Null(storedObj);
testObjects.RemoveAll();
testObjects.SaveChanges();
}
//===============================================================
public static void ChangeTracking(Repository<TestClass> repo)
{
var obj = new TestClass("myKey", "myValue");
repo.Insert(obj);
repo.SaveChanges();
var storedObj = repo.Find(obj.ID);
storedObj.Object.StringValue = "newValue";
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue", storedObj.Object.StringValue);
// Test changing list item
storedObj.Object.List.Add(4);
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual(4, storedObj.Object.List.Count);
// Test Update function
repo.Update(new { StringValue = "newValue2" }, storedObj.Object.ID);
repo.SaveChanges();
storedObj = repo.Find(obj.ID);
Assert.AreEqual("newValue2", storedObj.Object.StringValue);
repo.Remove(storedObj.Object);
repo.SaveChanges();
}
public ActionResult Gallery(GalleryVM gallery)
{
if (gallery != null && gallery.Images != null)
{
using (Repository r = new Repository())
{
foreach (var image in r.Files)
{
var i = gallery.Images.Find(x => x.ID == image.ID.ToString());
if (i == null)
{
r.Files.Remove(image);
}
else
{
image.Description = i.Description;
}
}
r.SaveChanges();
}
}
return View(GetGalleryVM());
}
private IEnumerable<EmployeeRight> SRVCUpdateRights(Helpers.Log.SessionInfo logSession, Repository.Logic.Repository rep,
long employeeId, IEnumerable<long> addRights, IEnumerable<long> removeRights, bool checkRights = true)
{
if (checkRights)
CheckBadRights(logSession, rep, Enumerable.Empty<long>()
.Union(addRights ?? Enumerable.Empty<long>())
.Union(removeRights ?? Enumerable.Empty<long>())
);
logSession.Add($"Get available rights from database");
var availableRights = rep.Get<Repository.Model.Right>(asNoTracking: true).ToArray();
#pragma warning disable 618
logSession.Add($"Try to get employee with id = {employeeId}");
var emp = rep.Get<Repository.Model.Employee>(e => e.EmployeeId == employeeId, false, new string[] { "Rights" }).FirstOrDefault();
if (emp == null)
throw new Exception(string.Format(Properties.Resources.STUFFINGSERVICE_EmployeeNotFound, employeeId));
var existedRights = emp.Rights.Select(r => r.RightId);
#region Add rights
if (addRights != null && addRights.Any())
{
logSession.Add($"Add rights...");
var addRightsUpper = addRights
.Except(existedRights)
.Join(availableRights, r => r, ar => ar.RightId, (r, ar) => ar)
.ToArray()
.Select(r => rep.New<Repository.Model.EmployeeRight>((er) =>
{
er.EmployeeId = emp.EmployeeId;
er.RightId = r.RightId;
//er.Employee = emp;
//er.Right = r;
})).ToArray();
logSession.Add($"Add this rights {addRightsUpper.Concat(r => r.RightId.ToString(), ",")} for employee id = {employeeId}");
foreach (var r in addRightsUpper)
emp.Rights.Add(r);
rep.AddRange(addRightsUpper, saveAfterInsert: false);
}
#endregion
#region Remove rights
if (removeRights != null && removeRights.Any())
{
logSession.Add($"Remove rights...");
var removeRightsUpper = removeRights
.Intersect(existedRights)
.Join(availableRights, r => r, ar => ar.RightId, (r, ar) => ar)
.ToArray()
.Join(emp.Rights, r => r.RightId, er => er.RightId, (r, er) => er)
.ToArray();
logSession.Add($"Remove this rights {removeRightsUpper.Concat(r => r.RightId.ToString(), ",")} for employee id = {employeeId}");
foreach (var r in removeRightsUpper)
emp.Rights.Remove(r);
rep.RemoveRange(removeRightsUpper, saveAfterRemove: false);
}
#endregion
rep.SaveChanges();
return emp.Rights.Select(r => AutoMapper.Mapper.Map<EmployeeRight>(r));
#pragma warning restore 618
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.SetData("DataDirectory", @"D:\Projects\WhiskyTracker\WhiskyTracker.DB");
Repository<Item> itemRepo = new Repository<Item>();
Repository<ItemType> itemTypeRepo = new Repository<ItemType>();
Repository<Price> priceRepo = new Repository<Price>();
/*
ItemType h = new ItemType();
List<Item> allItems = itemRepo.GetAll();
List<Price> allPrices = priceRepo.GetAll();
List<object> ai = (
from x in allItems.ToList() select new object()
).ToList().Concat(
from y in allPrices.ToList() select new object()
).ToList();
*/
foreach (ItemType itemType in itemTypeRepo.GetAll())
{
string TargetUrl = string.Format(Config.SAQUrl, itemType.CategoryId, 1024);
string HtmlContent = WebTools.SAQTools.GetUrlContentPost(TargetUrl, new NameValueCollection { { "requesttype", "ajax" }, { "searchResultsURL", TargetUrl } });
List<Item> items = WebTools.SAQTools.GetItemsFromContent(HtmlContent);
List<Price> prices = new List<Price>();
foreach (Item item in items)
{
Item dbItem = new Item();
if (itemRepo.IsValid(item))
{
item.ItemTypeID = itemType.ID;
itemRepo.Add(item);
dbItem = item;
}
else
{
dbItem = itemRepo.Single(x => x.StoreCode == item.StoreCode);
dbItem.ImageURL = item.ImageURL;
dbItem.Description = item.Description;
dbItem.ABV = item.ABV;
dbItem.Size = (item.Size == 0) ? dbItem.Size : item.Size;
dbItem.URL = item.URL;
dbItem.UPCCode = item.UPCCode;
dbItem.Producer = item.Producer;
itemRepo.Update(dbItem);
}
prices.Add(new Price { FetchedDate = DateTime.Now, ItemID = dbItem.ID, Value = item.Price });
List<WaybackMachineTools.Snapshot> archivedUrls = new List<WaybackMachineTools.Snapshot>();
try
{
archivedUrls = WebTools.WaybackMachineTools.GetItemSnapShots(item.URL);
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Error retrieving snapshots for URL {0}: {1}", item.URL, ex.Message));
}
foreach (WaybackMachineTools.Snapshot snapshot in archivedUrls)
{
string archivedContent = WebTools.SAQTools.GetUrlContentGet(snapshot.url);
if (archivedContent.IndexOf("<h1>ERREUR</h1>") > 0)
continue;
var archivedItem = WebTools.SAQTools.GetItemFromContent(archivedContent);
item.ImageURL = archivedItem.ImageURL;
prices.Add(new Price { Value = archivedItem.Price, FetchedDate = DateTime.ParseExact(snapshot.timestamp.Substring(0, 8), "yyyyMMdd", CultureInfo.InvariantCulture), ItemID = dbItem.ID });
}
foreach (Price price in prices)
{
if (priceRepo.IsValid(price))
priceRepo.Add(price);
}
prices.Clear();
}
}
itemRepo.SaveChanges();
priceRepo.SaveChanges();
}
public PartialViewResult SaveChangesDb(String types, String Values, String PropertyID, String ProjectID)
{
Guid PropID=Guid.Parse(PropertyID);
Guid ProjID=Guid.Parse(ProjectID);
if (types=="Bool")
{
var rep = new Repository();
var a = rep.PropertiesOfProjects.Where(q => q.PropertyID == PropID && q.ProjectID == ProjID).First();
rep.Histories.AddObject(new History {
RecordID=Guid.NewGuid(),
ProjectID=ProjID,
PropertyID=PropID,
PropertyValue=a.PropertyValue,
PropertyDateTimeModified=a.PropertyDateTimeModified,
PropertyPersonIDModified=a.PropertyPersonIDModified
});
a.PropertyValue = Values;
a.PropertyDateTimeModified = DateTime.Now;
rep.SaveChanges();
return PartialView("DisplayBool", new MyBool { a=bool.Parse(Values), test=Values});
}
else
{
var rep = new Repository();
var a = rep.PropertiesOfProjects.Where(q => q.PropertyID == PropID && q.ProjectID == ProjID);
foreach (var item in a)
{
rep.Histories.AddObject(new History
{
RecordID = Guid.NewGuid(),
ProjectID = ProjID,
PropertyID = PropID,
PropertyValue = item.PropertyValue,
PropertyDateTimeModified = item.PropertyDateTimeModified,
PropertyPersonIDModified = item.PropertyPersonIDModified
});
rep.PropertiesOfProjects.DeleteObject(item);
}
List<ValueTransfer> listValues = manager.ParseInputValues(Values);
foreach (var value in listValues)
{
/*
rep.DefaultValues.AddObject(new DefaultValue
{
PropertyID = PropID,
Value = value.Value,
ValueID = Guid.NewGuid()
});*/
/*
if (value.IsAssigned)
{*/
rep.PropertiesOfProjects.AddObject(new PropertiesOfProject
{
ProjectID = ProjID,
PropertyID = PropID,
RecordID = Guid.NewGuid(),
PropertyPersonIDModified = Guid.Parse("e9e71093-7327-427a-86cb-50f255bc8301"), // TODO: Autorization
PropertyValue = value.Value,
PropertyDateTimeModified = DateTime.Now
});
/*}*/
}
rep.SaveChanges();
return PartialView("DisplayFields", rep.PropertiesOfProjects.Where(q=>q.PropertyID==PropID && q.ProjectID==ProjID));
}
}
//===============================================================
public static void Exists(Repository<TestClass> repo)
{
repo.RemoveAll();
repo.SaveChanges();
var item = new TestClass { ID = "1", StringValue = "blah" };
repo.Insert(item);
repo.SaveChanges();
Assert.IsTrue(repo.Exists(item));
repo.RemoveAll();
repo.SaveChanges();
}
//================================================================================
public static void ChangeTrackingEnumeratedObjects(Repository<TestClass> repo)
{
// Test changing enumerated objects
var objects = Enumerable.Range(0, 10).Select(x => new TestClass(x.ToString(), x.ToString()));
repo.Insert(objects);
repo.SaveChanges();
foreach (var item in repo.Items)
Assert.AreEqual(item.ID, item.StringValue);
foreach (var item in repo.Items)
item.StringValue = ((int.Parse(item.StringValue)) + 1).ToString();
repo.SaveChanges();
foreach (var item in repo.Items)
Assert.AreNotEqual(item.ID, item.StringValue);
repo.RemoveAll();
repo.SaveChanges();
}
