public void GetAll_WhenCalled_ReturnsAllPlants() { var data = new List <Plant> { new Plant("plant1", 1, DateTime.UtcNow) { Id = 1 }, new Plant("plant2", 2, DateTime.UtcNow) { Id = 2 }, }.AsQueryable(); var mockSet = new Mock <DbSet <Plant> >(); mockSet.As <IQueryable <Plant> >().Setup(m => m.Provider).Returns(data.Provider); mockSet.As <IQueryable <Plant> >().Setup(m => m.Expression).Returns(data.Expression); mockSet.As <IQueryable <Plant> >().Setup(m => m.ElementType).Returns(data.ElementType); mockSet.As <IQueryable <Plant> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator()); var mockContext = new Mock <PlantAppDbContext>(); mockContext.Setup(m => m.Plants).Returns(mockSet.Object); var service = new PlantRepository(mockContext.Object); var plants = service.GetAll(); Assert.AreEqual("plant1", plants[0].Name); Assert.AreEqual("plant2", plants[1].Name); }
public void Get_WithPlantMatchingGuidInRepo_ShouldReturnMatchingPlant() { using (var context = new RamosiContext(options)) { // Arrange var plants = new List <Plant>() { new PlantBuilder() .WithGuid(guidOne) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidOne)), new PlantBuilder() .WithGuid(guidTwo) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidTwo)), new PlantBuilder() .WithGuid(guidThree) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidThree)), }; context.Plants.AddRange(plants); context.SaveChanges(); var repo = new PlantRepository(context); // Act var plant = repo.Get(guidTwo); // Assert Assert.AreEqual(guidTwo, plant.Guid); Assert.AreEqual(guidTwo, plant.PlantCharacteristic.Guid); } }
public ActionResult <List <Plant> > GetAllPlants() { List <Plant> plants = new List <Plant>(); plants = PlantRepository.GetAllPlants(); return(plants); }
public ActionResult <(string, string)> GetIncompatibilities(string plantGroupName, string plantName, string accountID) { var plantGroup = PlantGroupRepository.GetByName(plantGroupName, accountID); if (plantGroup == null) { return(NotFound()); } var plant = PlantRepository.GetByName(plantName); if (plant == null) { return(NotFound()); } List <(Plant, List <IPlantRequirement>)> requirementList = plantGroup.GetAllIncompatibilities(plant); List <(string, string)> expandedList = new List <(string, string)>(); foreach ((Plant, List <IPlantRequirement>)reqPair in requirementList) { foreach (IPlantRequirement req in reqPair.Item2) { expandedList.Add((reqPair.Item1.Name, req.TypeOfReq())); } } return(Ok(expandedList)); }
public void DeletePlantFromPlantGroup(string gardenName, string plantGroupName, string plantName, string accountID) { if (string.IsNullOrEmpty(gardenName)) { throw new ArgumentException("message", nameof(gardenName)); } if (string.IsNullOrEmpty(plantGroupName)) { throw new ArgumentException("message", nameof(plantGroupName)); } if (string.IsNullOrEmpty(plantName)) { throw new ArgumentException("message", nameof(plantName)); } Garden garden = GardenRepository.GetByName(gardenName, accountID); PlantGroup plantGroup = PlantGroupRepository.GetByName(plantGroupName, accountID); Plant plant = PlantRepository.GetByName(plantName); //Not sure this is needed? plantGroup.DeletePlant(plant); PlantGroupRepository.DeletePlantFromPlantGroup(plantGroup, plant, accountID); }
public void AddPlantToPlantGroup(string gardenName, string plantGroupName, string plantName, string accountID) { if (string.IsNullOrEmpty(gardenName)) { throw new ArgumentException("message", nameof(gardenName)); } if (string.IsNullOrEmpty(plantGroupName)) { throw new ArgumentException("message", nameof(plantGroupName)); } if (string.IsNullOrEmpty(plantName)) { throw new ArgumentException("message", nameof(plantName)); } Garden garden = GardenRepository.GetByName(gardenName, accountID); PlantGroup plantGroup = PlantGroupRepository.GetByName(plantGroupName, accountID); Plant plant = PlantRepository.GetByName(plantName); plantGroup.AddPlant(plant); PlantGroupRepository.AddPlantToPlantGroup(plantGroup, plant, accountID); //should be update }
public IActionResult Plant(int id) { PlantRepository r = new PlantRepository(); Plant p = r.GetPlant(id); return(View(p)); }
public HomeController(ILogger <HomeController> logger, DataContext dataContext, PlantRepository plantRepository, UserManager <User> userManager) { _logger = logger; _dataContext = dataContext; _plantRepository = plantRepository; _userManager = userManager; }
public async Task Delete_WithNoMatchingPlantInRepo_ShouldNotDeleteExistingRecord() { using (var context = new RamosiContext(options)) { // Arrange var plant = new PlantBuilder() .WithGuid(guidOne) .WithName("Plant") .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithNotes("This is a characteristic")) .WithPlantCollection(new List <PlantCollection> { new PlantCollectionBuilder().WithNickname("Part of the collection") }); context.Plants.Add(plant); context.SaveChanges(); var repo = new PlantRepository(context); // Act Assert.Throws <ArgumentException>(() => repo.Delete(guidTwo), $"No entity of type Plant with guid {guidTwo} was found"); await repo.SaveChanges(); // Assert Assert.AreEqual(1, context.Plants.Count()); Assert.AreEqual(guidOne, context.Plants.First().Guid); } }
public void Delete_WhenCalled_DeletesPlantFromDatabase() { var data = new List <Plant> { new Plant("plant1", 1, DateTime.UtcNow), new Plant("plant2", 2, DateTime.UtcNow), }.AsQueryable(); var mockSet = new Mock <DbSet <Plant> >(); mockSet.As <IQueryable <Plant> >().Setup(m => m.Provider).Returns(data.Provider); mockSet.As <IQueryable <Plant> >().Setup(m => m.Expression).Returns(data.Expression); mockSet.As <IQueryable <Plant> >().Setup(m => m.ElementType).Returns(data.ElementType); mockSet.As <IQueryable <Plant> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator()); var mockContext = new Mock <PlantAppDbContext>(); mockContext.Setup(m => m.Plants).Returns(mockSet.Object); var service = new PlantRepository(mockContext.Object); service.Delete(mockContext.Object.Plants.First()); mockSet.Verify(m => m.Remove(It.IsAny <Plant>()), Times.Once); mockContext.Verify(m => m.SaveChanges(), Times.Once()); }
public async Task Create_WithPlant_ShouldSavePlantInDatabase() { using (var context = new RamosiContext(options)) { // Arrange var plant = new PlantBuilder() .WithName("Plant") .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithNotes("This is a characteristic")) .WithPlantCollection(new List <PlantCollection> { new PlantCollectionBuilder().WithNickname("Part of the collection") }); var repo = new PlantRepository(context); // Act repo.Create(plant); await repo.SaveChanges(); // Assert Assert.AreEqual(1, context.Plants.Count()); var created = context.Plants.First(); Assert.AreEqual("Plant", created.Name); Assert.AreEqual("This is a characteristic", created.PlantCharacteristic.Notes); Assert.AreEqual(1, created.PlantCollection.Count); Assert.AreEqual("Part of the collection", created.PlantCollection.First().Nickname); } }
public Kwekerij(string bedrijfsnaam, string straat, string postcode, string plaats, string telefoonnummer, string faxnummer, string mobiel, string email, string iban, string btwNummer, string kvkNummer) { // Initialize Properties Bedrijfsnaam = bedrijfsnaam; Straat = straat; Postcode = postcode; Plaats = plaats; Telefoonnummer = telefoonnummer; Faxnummer = faxnummer; Mobiel = mobiel; Email = email; Iban = iban; BtwNummer = btwNummer; KvkNummer = kvkNummer; // Initialize Repositories with Contexts klantRepo = new KlantRepository(new KlantSQLiteContext()); bestellingRepo = new BestellingRepository(new BestellingSQLiteContext()); plantRepo = new PlantRepository(new PlantSQLiteContext()); // Initialize Lists Klanten = new ObservableCollection <Klant>(klantRepo.GetAll()); Planten = new ObservableCollection <Plant>(plantRepo.GetAll()); Bestellingen = new ObservableCollection <Bestelling>(bestellingRepo.GetAll()); // Bind foreach (Bestelling bestelling in Bestellingen) { bestelling.Klant = Klanten.Single(k => k.Id == bestelling.Klant.Id); foreach (Bestelregel bestelregel in bestelling.Bestelregels) { bestelregel.Plant = Planten.Single(p => p.Id == bestelregel.Plant.Id); } } // Initialialize Change Events in Observable Lists Klanten.CollectionChanged += ObservableListCollection_CollectionChanged; foreach (Klant klant in Klanten) { klant.PropertyChanged += ItemPropertyChanged; } Planten.CollectionChanged += ObservableListCollection_CollectionChanged; foreach (Plant plant in Planten) { plant.PropertyChanged += ItemPropertyChanged; } Bestellingen.CollectionChanged += ObservableListCollection_CollectionChanged; foreach (Bestelling bestelling in Bestellingen) { bestelling.PropertyChanged += ItemPropertyChanged; bestelling.Bestelregels.CollectionChanged += ObservableListCollection_CollectionChanged; foreach (Bestelregel bestelregel in bestelling.Bestelregels) { bestelregel.Leveringen.CollectionChanged += ObservableListCollection_CollectionChanged; } } }
public IActionResult PlantsByShadePreference(string id = "") { ViewData["Title"] = "Plants by Shade Preference"; PlantRepository r = new PlantRepository(); PlantsByAttributeViewModel model = r.GetPlantsByShadePreference(id); return(View(model)); }
public IActionResult PlantsByHabitat(string id = "") { ViewData["Title"] = "Plants by Habitat"; PlantRepository r = new PlantRepository(); PlantsByAttributeViewModel model = r.GetPlantsByHabitat(id); return(View(model)); }
//te doen - zorg ervoor dat de aantal en uploadsdatum te zien zijn voor andere gebruikers - zorg ook voor checks of ze er zijn wanneer je dit doet. public PlantsController(DataContext context, UserManager <User> userManager, UploadService upload, PlantRepository plantRepository) { _context = context; _userManager = userManager; _uploadService = upload; _plantRepository = plantRepository; }
public IActionResult PlantsByType() { ViewData["Title"] = "Plants by Plant Type"; PlantRepository r = new PlantRepository(); PlantsByAttributeViewModel model = r.GetPlantsByType(); return(View(model)); }
public ActionResult <Plant> GetPlantByName(string name) { var plant = PlantRepository.GetByName(name); if (plant != null) { return(plant); } return(NotFound()); }
public void Get_WithNoPlantsInRepo_ShouldReturnNull() { using (var context = new RamosiContext(options)) { // Arrange var repo = new PlantRepository(context); // Act var plant = repo.Get(guidOne); // Assert Assert.IsNull(plant); } }
public void GetAll_WithNoPlantsInRepo_ShouldReturnEmptyCollection() { using (var context = new RamosiContext(options)) { // Arrange var repo = new PlantRepository(context); // Act var plants = repo.Get(); // Assert Assert.IsFalse(plants.Any()); } }
public void Create_WithNullPlant_ShouldNotSavePlant() { using (var context = new RamosiContext(options)) { // Arrange var repo = new PlantRepository(context); // Act Assert.Throws <ArgumentNullException>(() => repo.Create(null), "Entity of type Plant cannot be null"); // Assert Assert.IsFalse(context.Plants.Any()); } }
public async Task Delete_WithNoPlantsInRepo_ShouldNotModifyDatabase() { using (var context = new RamosiContext(options)) { // Arrange var repo = new PlantRepository(context); // Act Assert.Throws <ArgumentException>(() => repo.Delete(guidOne), $"No entity of type Plant with guid {guidOne} was found"); await repo.SaveChanges(); // Assert Assert.IsFalse(context.Plants.Any()); } }
public void Add_WhenCalled_AddsPlantToDatabase() { var mockSet = new Mock <DbSet <Plant> >(); var mockContext = new Mock <PlantAppDbContext>(); mockContext.Setup(m => m.Plants).Returns(mockSet.Object); var service = new PlantRepository(mockContext.Object); var plant = new Plant("plant1", 1, DateTime.UtcNow); service.Add(plant); mockSet.Verify(m => m.Add(It.IsAny <Plant>()), Times.Once()); mockContext.Verify(m => m.SaveChanges(), Times.Once()); }
public async Task Edit_WithPlantWithMatchingGuidInRepo_ShouldNotEditPlantCharacteristicOrPlantCollection() { using (var context = new RamosiContext(options)) { // Arrange var plants = new List <Plant>() { new PlantBuilder() .WithName("one") .WithPlantCharacteristic(new PlantCharacteristicBuilder() .WithNotes("note one")) .WithPlantCollection(new List <PlantCollection>() { new PlantCollectionBuilder().WithNickname("nickname one") }), }; context.Plants.AddRange(plants); context.SaveChanges(); var plant = new PlantBuilder() .WithName("changed one!") .WithPlantCharacteristic(new PlantCharacteristicBuilder() .WithNotes("changed note one!")) .WithPlantCollection(new List <PlantCollection>() { new PlantCollectionBuilder().WithNickname("changed nickname one!") }); var repo = new PlantRepository(context); // Act repo.Edit(plant); await repo.SaveChanges(); // Arrange Assert.AreEqual(1, context.Plants.Count()); var plantsInDb = context.Plants.ToList(); Assert.AreEqual(guidOne, plantsInDb[0].PlantCharacteristic.Guid); Assert.AreEqual("note one", plantsInDb[0].PlantCharacteristic.Notes); Assert.AreEqual(guidOne, plantsInDb[0].PlantCollection[0].Guid); Assert.AreEqual("nickname one", plantsInDb[0].PlantCollection[0].Nickname); } }
public List <Plant> FetchFordTree() { try { List <Plant> ret = PlantRepository.GetPlants(true); FISLogging.Log("[200-OK] Params: "); return(ret); } catch (Exception ex) { FISLogging.Log("[E] Exception Encountered: " + ex.Message); FISLogging.Log("[E-P] Params: "); FISLogging.Log("[E-ST] " + ex.StackTrace); HttpContext.Current.Response.StatusCode = 500; throw ex; } }
public static (AccessService, Mock <IGraphService>) Factory(QueueReceiverServiceContext context) { var personCreatedByCache = new PersonCreatedByCache(111) { Username = "******" }; var personRepository = new PersonRepository(context); var graphServiceMock = new Mock <IGraphService>(); var projectRepositoryMock = new Mock <IProjectRepository>(); var personProjectRepositoryMock = new Mock <IPersonProjectRepository>(); var personServiceLoggerMock = new Mock <ILogger <PersonService> >(); var personService = new PersonService(personRepository, graphServiceMock.Object, projectRepositoryMock.Object, personCreatedByCache, personProjectRepositoryMock.Object, personServiceLoggerMock.Object); var personProjectRepository = new PersonProjectRepository(context); var projectRepository = new ProjectRepository(context); var personUserGroupRepository = new PersonUserGroupRepository(context); var userGroupRepository = new UserGroupRepository(context); var personRestrictionRoleRepository = new PersonRestrictionRoleRepository(context); var restrictionRoleRepository = new RestrictionRoleRepository(context); var privilegeService = new PrivilegeService(restrictionRoleRepository, personRestrictionRoleRepository, userGroupRepository, personUserGroupRepository, personCreatedByCache); var personProjectHistoryRepository = new PersonProjectHistoryRepository(context); var plantRepository = new PlantRepository(context); var plantService = new PlantService(plantRepository); var AccessServiceloggerMock = new Mock <ILogger <AccessService> >(); var personProjectServiceLoggerMock = new Mock <ILogger <PersonProjectService> >(); var personProjectService = new PersonProjectService( personProjectRepository, projectRepository, privilegeService, personProjectHistoryRepository, personService, personProjectServiceLoggerMock.Object, personCreatedByCache); var service = new AccessService(personService, personProjectService, plantService, AccessServiceloggerMock.Object, context, personCreatedByCache); return(service, graphServiceMock); }
public void GetAll_WithPlantsInRepo_ShouldReturnAllPlants() { using (var context = new RamosiContext(options)) { // Arrange var plantsInRepo = new List <Plant>() { new PlantBuilder() .WithGuid(guidOne) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidOne)), new PlantBuilder() .WithGuid(guidTwo) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidTwo)), new PlantBuilder() .WithGuid(guidThree) .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidThree)), }; context.Plants.AddRange(plantsInRepo); context.SaveChanges(); var repo = new PlantRepository(context); // Act var plants = repo.Get(); // Assert Assert.AreEqual(3, plants.Count()); var results = plants.ToList(); Assert.AreEqual(guidOne, results[0].Guid); Assert.AreEqual(guidOne, results[0].PlantCharacteristic.Guid); Assert.AreEqual(guidTwo, results[1].Guid); Assert.AreEqual(guidTwo, results[1].PlantCharacteristic.Guid); Assert.AreEqual(guidThree, results[2].Guid); Assert.AreEqual(guidThree, results[2].PlantCharacteristic.Guid); } }
public async Task Delete_WithPlantsInRepo_ShouldOnlyDeletePlantWithMatchingGuid() { using (var context = new RamosiContext(options)) { // Arrange var plants = new List <Plant>() { new PlantBuilder() .WithGuid(guidOne).WithName("one"), new PlantBuilder() .WithGuid(guidTwo).WithName("two") .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidTwo)), new PlantBuilder() .WithGuid(guidThree).WithName("three") .WithPlantCharacteristic(new PlantCharacteristicBuilder().WithGuid(guidThree)) }; context.Plants.AddRange(plants); context.SaveChanges(); var repo = new PlantRepository(context); // Act repo.Delete(guidTwo); await repo.SaveChanges(); // Assert Assert.AreEqual(2, context.Plants.Count()); var plantsInRepo = context.Plants.ToList(); Assert.AreEqual(guidOne, plantsInRepo[0].Guid); Assert.AreEqual("one", plantsInRepo[0].Name); Assert.AreEqual(guidThree, plantsInRepo[1].Guid); Assert.AreEqual("three", plantsInRepo[1].Name); } }
public PlantController() { IPlantRepository plantRepository = new PlantRepository(); _plantService = new PlantService(plantRepository); }
public PlantDomain(PlantRepository plantRepository) { this.plantRepository = plantRepository; }
public PlantsController(DataContext context, PlantRepository plantRepository) { this._dataContext = context; this._plantRepository = plantRepository; }