public HttpResponseMessage GetSuppliersByAdmin(int adminId)
{
ItemsResponse <Suppliers> response = new ItemsResponse <Suppliers>();
response.Items = SuppliersService.GetSuppliersByAdmin(adminId);
return(Request.CreateResponse(response));
}
public HttpResponseMessage GetListOfSuppliers()
{
ItemsResponse <Suppliers> response = new ItemsResponse <Suppliers>();
response.Items = SuppliersService.GetListOfSuppliers();
return(Request.CreateResponse(response));
}
public HttpResponseMessage GetSupplier(int id)
{
ItemResponse <Suppliers> response = new ItemResponse <Suppliers>();
response.Item = SuppliersService.GetSupplier(id);
return(Request.CreateResponse(response));
}
public async Task CreateSupplierAsyncShouldCreateSupplierSuccessfully()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MyCalisthenicAppProfile());
});
var mapper = mockMapper.CreateMapper();
var suppliersService = new SuppliersService(dbContext, mapper);
var supplierModel = new SupplierAdminCreateViewModel
{
Name = SupplierName,
PriceToHome = SupplierPriceToHome,
PriceToOffice = SupplierPriceToOffice,
};
await suppliersService.CreateSupplierAsync(supplierModel);
var actual = await dbContext.Suppliers.FirstOrDefaultAsync();
Assert.Equal(supplierModel.Name, actual.Name);
}
public async Task GetSupplierByIdAsyncShouldReturnSupplierSuccessfully()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MyCalisthenicAppProfile());
});
var mapper = mockMapper.CreateMapper();
var suppliersService = new SuppliersService(dbContext, mapper);
var supplier = new Supplier
{
Name = SupplierName,
PriceToHome = SupplierPriceToHome,
PriceToOffice = SupplierPriceToOffice,
};
await dbContext.Suppliers.AddAsync(supplier);
await dbContext.SaveChangesAsync();
var expected = await suppliersService.GetSupplierByIdAsync(supplier.Id);
Assert.Equal(expected.Id, supplier.Id);
}
public HttpResponseMessage DeleteSupplier(int id)
{
SuccessResponse response = new SuccessResponse();
SuppliersService.DeleteSupplier(id);
return(Request.CreateResponse(response));
}
public void CreateShouldCreateSupplierAndIsDefaultShouldStayFalse()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "CreateIsDefaultFalse_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
dbContext.Suppliers.Add(new Supplier {
Name = "Econt", IsDefault = true
});
dbContext.SaveChanges();
var name = "DHL";
var priceToHome = 5.5M;
var priceToOffice = 4.5M;
suppliersService.Create(name, priceToHome, priceToOffice);
var supplier = dbContext.Suppliers.FirstOrDefault(x => x.Name == name);
Assert.NotNull(supplier);
Assert.Equal(name, supplier.Name);
Assert.Equal(priceToHome, supplier.PriceToHome);
Assert.Equal(priceToOffice, supplier.PriceToOffice);
Assert.False(supplier.IsDefault);
}
public void CalculateTotalCost_WithPercentageShipping_Should_Return_RightCost()
{
//Arrange
var jsonService = new JsonService();
var suppliersService = new SuppliersService(jsonService);
var ordersService = new OrdersService(suppliersService, jsonService);
var supplier = new Supplier
{
Name = "Supplier D",
ShippingPercentage = 6,
WaffleProducts = new Products
{
Ordinary = 2,
SugarFree = 2.5M,
Super = 2.8M
}
};
var Order = new Order
{
OrdinaryCount = 2,
SugarFreeCount = 3,
SuperCount = 4
};
var expected = 21.094M;
//Act
var totalCost = ordersService.CalculateTotalCost(supplier, Order);
//Assert
Assert.IsTrue(totalCost == expected);
}
public void AllShouldReturnListWithAllSuppliers()
{
var options = new DbContextOptionsBuilder <BookStoreDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
//
var dbContext = new BookStoreDbContext(options);
var supplierService = new SuppliersService(dbContext);
var suppliers = new List <Supplier>
{
new Supplier()
{
Name = "Speedy",
PriceToOffice = 4.99M,
PriceToHome = 5.99M
},
new Supplier()
{
Name = "Eccont",
PriceToOffice = 5.99M,
PriceToHome = 6.99M
},
};
dbContext.Suppliers.AddRange(suppliers);
dbContext.SaveChanges();
var listWithSuppliers = supplierService.All().ToList();
Assert.True(listWithSuppliers.Count == 2);
}
public async Task DeleteAsyncShouldWorkCorrectlyUsingMoq()
{
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30
},
new Supplier {
Id = 2
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(suppliers.AsQueryable());
repository.Setup(r => r.Delete(It.IsAny <Supplier>())).Callback((Supplier item) => suppliers.Remove(item));
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new SuppliersService(repository.Object);
Assert.True(await service.DeleteAsync(1));
Assert.Single(suppliers);
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
repository.Verify(x => x.Delete(It.IsAny <Supplier>()), Times.Once);
repository.Verify(x => x.SaveChangesAsync());
}
public async Task EditSupplierAsyncShouldThrowExceptionIfSupplierIsNull()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MyCalisthenicAppProfile());
});
var mapper = mockMapper.CreateMapper();
var suppliersService = new SuppliersService(dbContext, mapper);
var supplierModel = new SupplierAdminEditViewModel
{
Name = SupplierName,
PriceToHome = SupplierPriceToHome,
PriceToOffice = SupplierPriceToOffice,
};
var exception = await Assert.ThrowsAsync <ArgumentNullException>(async() => await suppliersService.EditSupplierAsync(supplierModel));
Assert.IsType <ArgumentNullException>(exception);
}
public void GetDiliveryPriceShouldReturnDiliveryPrice()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "GetDiliveryPrice_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
var suppliers = new List <Supplier>
{
new Supplier {
Name = "Econt", PriceToHome = 4.5M, PriceToOffice = 3.5M
},
new Supplier {
Name = "DHL", PriceToHome = 3.2M, PriceToOffice = 2.8M
},
};
dbContext.Suppliers.AddRange(suppliers);
dbContext.SaveChanges();
var homeDeliveryPrice = suppliersService.GetDiliveryPrice(suppliers.First().Id, DeliveryType.Home);
var officeDeliveryPrice = suppliersService.GetDiliveryPrice(suppliers.First().Id, DeliveryType.Office);
Assert.Equal(homeDeliveryPrice, suppliers.First().PriceToHome);
Assert.Equal(officeDeliveryPrice, suppliers.First().PriceToOffice);
}
public void EditShouldEditSupplier()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "Edit_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
var supplier = new Supplier
{
Name = "DHL",
PriceToHome = 4.5M,
PriceToOffice = 5.5M
};
dbContext.Suppliers.Add(supplier);
dbContext.SaveChanges();
var name = "econt";
var priceToHome = 3.5M;
var priceToOffice = 3M;
suppliersService.Edit(supplier.Id, name, priceToHome, priceToOffice);
Assert.Equal(name, supplier.Name);
Assert.Equal(priceToHome, supplier.PriceToHome);
Assert.Equal(priceToOffice, supplier.PriceToOffice);
}
public void GetSupplierByIdShouldReturnSupplier()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "GetSupplierById_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
var supplierId = 1;
var supplierName = "Econt";
var suppliers = new List <Supplier>
{
new Supplier {
Id = supplierId, Name = supplierName, IsDefault = true
},
new Supplier {
Id = 2, Name = "DHL", IsDefault = false
},
};
dbContext.Suppliers.AddRange(suppliers);
dbContext.SaveChanges();
var supplier = suppliersService.GetSupplierById(supplierId);
Assert.Equal(supplierName, supplier.Name);
}
public void MakeDafaultShouldSwapDefaultSupplier()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "MakeDafaultSwap_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
var suppliers = new List <Supplier>
{
new Supplier {
Name = "Econt", IsDefault = true
},
new Supplier {
Name = "DHL", IsDefault = false
},
};
dbContext.Suppliers.AddRange(suppliers);
dbContext.SaveChanges();
suppliersService.MakeDafault(suppliers.Last().Id);
Assert.False(suppliers.First().IsDefault);
Assert.True(suppliers.Last().IsDefault);
}
//Search Entities
public async Task <IEnumerable <Suppliers> > SearchSuppliers(List <string> lst, List <string> includeLst = null)
{
using (var ctx = new SuppliersService())
{
return(await ctx.GetSuppliersByExpressionLst(lst, includeLst).ConfigureAwait(false));
}
}
public void AddSupplier_ShouldReturn_Success()
{
// Arrange
SuppliersModel supplier = new SuppliersModel
{
Name = "New supplier",
Link = "Suppliers link1",
Currency = "Eur",
Notes = "some notes for supplier1"
};
fakeSuppliersRepository.Setup(a => a.Add(supplier));
suppliersService = new SuppliersService(fakeSuppliersRepository.Object);
SuppliersDtoModel supplierDto = new SuppliersDtoModel()
{
Name = supplier.Name,
Link = supplier.Link,
Currency = supplier.Currency,
Notes = supplier.Notes
};
try
{
// Act
suppliersService.AddSupplier(supplierDto);
operationSucceeded = true;
}
catch (Exception ex)
{
errorMessage = ex.Message + " | " + ex.StackTrace;
}
// Assert
Assert.IsTrue(operationSucceeded, errorMessage);
}
public void GetAllGenericShouldMapCorrectlyUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30, IsDefault = true
},
new Supplier {
Id = 2
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(suppliers.AsQueryable());
var service = new SuppliersService(repository.Object);
Assert.Equal(1, service.GetAll <SupplierViewModel>().FirstOrDefault().Id);
Assert.Equal("TestName1", service.GetAll <SupplierViewModel>().FirstOrDefault().Name);
Assert.Equal(25, service.GetAll <SupplierViewModel>().FirstOrDefault().PriceToHome);
Assert.Equal(30, service.GetAll <SupplierViewModel>().FirstOrDefault().PriceToOffice);
Assert.True(service.GetAll <SupplierViewModel>().FirstOrDefault().IsDefault);
repository.Verify(x => x.AllAsNoTracking(), Times.Exactly(5));
}
public async Task MakeDafaultAsyncShouldWorkCorrectlyWhenThereIsADefaultSupplierUsingMoq()
{
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30, IsDefault = true
},
new Supplier {
Id = 2, Name = "TestName2", PriceToHome = 25, PriceToOffice = 30, IsDefault = false
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(suppliers.AsQueryable());
repository.Setup(r => r.Update(It.IsAny <Supplier>())).Callback((Supplier item) =>
{
var foundSupplier = suppliers.FirstOrDefault(x => x.Id == item.Id);
foundSupplier.IsDefault = item.IsDefault;
});
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new SuppliersService(repository.Object);
Assert.True(await service.MakeDafaultAsync(2));
Assert.False(suppliers.FirstOrDefault(x => x.Id == 1).IsDefault);
Assert.True(suppliers.FirstOrDefault(x => x.Id == 2).IsDefault);
repository.Verify(x => x.AllAsNoTracking(), Times.Exactly(2));
repository.Verify(x => x.Update(It.IsAny <Supplier>()), Times.Exactly(2));
repository.Verify(x => x.SaveChangesAsync());
}
public async Task EditAsyncGenericShouldReturnFalseWithInvalidSupplierIdUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30, IsDefault = false
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(suppliers.AsQueryable());
var service = new SuppliersService(repository.Object);
var model = new EditSupplierViewModel {
Id = 2
};
Assert.False(await service.EditAsync(model));
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public async Task CreateAsyncGenericShouldIncreaseCountUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30
},
};
repository.Setup(r => r.AddAsync(It.IsAny <Supplier>())).Callback((Supplier item) => suppliers.Add(item));
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new SuppliersService(repository.Object);
var model = new CreateSupplierInputViewModel
{
Name = "TestName2",
PriceToHome = 35,
PriceToOffice = 40,
};
await service.CreateAsync(model);
Assert.Equal(2, suppliers.Count);
repository.Verify(x => x.AddAsync(It.IsAny <Supplier>()), Times.Once);
repository.Verify(x => x.SaveChangesAsync());
}
public async Task CreateAsyncGenericShouldMapCorrectlyWhenThereIsDefaultSupplierUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30, IsDefault = true
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(suppliers.AsQueryable());
repository.Setup(r => r.AddAsync(It.IsAny <Supplier>())).Callback((Supplier item) => suppliers.Add(item));
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new SuppliersService(repository.Object);
var model = new CreateSupplierInputViewModel
{
Name = "TestName2",
PriceToHome = 35,
PriceToOffice = 40,
};
await service.CreateAsync(model);
Assert.Equal("TestName2", suppliers.Last().Name);
Assert.Equal(35, suppliers.Last().PriceToHome);
Assert.Equal(40, suppliers.Last().PriceToOffice);
Assert.False(suppliers.Last().IsDefault);
repository.Verify(x => x.AddAsync(It.IsAny <Supplier>()), Times.Once);
repository.Verify(x => x.SaveChangesAsync());
}
public NewOrderDialog(BadgerDataModel context)
{
InitializeComponent();
_context = context;
_jobService = new JobsService(_context);
_supplierService = new SuppliersService(context);
tbSupplier.Validated += TbSupplier_Validated;
tbJobSelection.Validated += TbJobSelection_Validated;
AutoCompleteStringCollection jobNames = new AutoCompleteStringCollection();
foreach (var item in _jobService.All())
{
jobNames.Add(item.JobName);
}
this.tbJobSelection.AutoCompleteMode = AutoCompleteMode.Suggest;
this.tbJobSelection.AutoCompleteSource = AutoCompleteSource.CustomSource;
tbJobSelection.AutoCompleteCustomSource = jobNames;
AutoCompleteStringCollection supplierNames = new AutoCompleteStringCollection();
foreach (var item in _supplierService.GetAll())
{
supplierNames.Add(item.SupplierName);
}
this.tbSupplier.AutoCompleteMode = AutoCompleteMode.Suggest;
this.tbSupplier.AutoCompleteSource = AutoCompleteSource.CustomSource;
tbSupplier.AutoCompleteCustomSource = supplierNames;
CheckState();
}
public void DeleteDefaultSupplierShouldReturnFalse()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteDefaultSupplier_Supplier_Database")
.Options;
var dbContext = new XeonDbContext(options);
var suppliersService = new SuppliersService(dbContext);
var suppliers = new List <Supplier>
{
new Supplier {
Name = "Econt", IsDefault = true
},
new Supplier {
Name = "DHL", IsDefault = false
},
};
dbContext.Suppliers.AddRange(suppliers);
dbContext.SaveChanges();
var isDeleted = suppliersService.Delete(suppliers.First().Id);
Assert.Equal(2, dbContext.Suppliers.Count());
Assert.False(isDeleted);
}
public async Task UndeleteAsyncShouldWorkCorrectlyUsingMoq()
{
var repository = new Mock <IDeletableEntityRepository <Supplier> >();
var suppliers = new List <Supplier>
{
new Supplier {
Id = 1, Name = "TestName1", PriceToHome = 25, PriceToOffice = 30, IsDeleted = true, DeletedOn = DateTime.UtcNow
},
new Supplier {
Id = 2
},
};
repository.Setup(r => r.AllAsNoTrackingWithDeleted()).Returns(suppliers.AsQueryable());
repository.Setup(r => r.Undelete(It.IsAny <Supplier>())).Callback((Supplier item) =>
{
var foundSupplier = suppliers.FirstOrDefault(x => x.Id == item.Id);
foundSupplier.IsDeleted = false;
foundSupplier.DeletedOn = null;
});
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new SuppliersService(repository.Object);
Assert.True(await service.UndeleteAsync(1));
Assert.False(suppliers.FirstOrDefault().IsDeleted);
Assert.Null(suppliers.FirstOrDefault().DeletedOn);
repository.Verify(x => x.AllAsNoTrackingWithDeleted(), Times.Once);
repository.Verify(x => x.Undelete(It.IsAny <Supplier>()), Times.Once);
repository.Verify(x => x.SaveChangesAsync());
}
public MainViewTests()
{
ErrorMessageView errorMessageView = new ErrorMessageView();
DeleteConfirmView deleteConfirmView = new DeleteConfirmView();
mainView = new MainView(errorMessageView);
SettingsPresenter settingsPresenter = new SettingsPresenter(new SettingsUC(errorMessageView), errorMessageView);
StoreFacade facade = ServicesInitialiser.facade;
UnitsService unitsService = ServicesInitialiser.unitsService;
UnitsDetailUC unitsDetailUC = new UnitsDetailUC(errorMessageView);
UnitsDetailPresenter unitsDetailPresenter = new UnitsDetailPresenter(unitsDetailUC, facade);
UnitsPresenter unitsPresenter = new UnitsPresenter(new UnitsUC(errorMessageView), facade, unitsDetailPresenter, deleteConfirmView, errorMessageView);
SuppliersService supplierService = ServicesInitialiser.suppliersService;
SuppliersDetailUC suppliersDetailUC = new SuppliersDetailUC(errorMessageView);
SuppliersDetailPresenter suppliersDetailPresenter = new SuppliersDetailPresenter(suppliersDetailUC, facade);
SuppliersPresenter suppliersPresenter = new SuppliersPresenter(new SuppliersUC(errorMessageView), suppliersDetailPresenter, facade, deleteConfirmView, errorMessageView);
ProductsService productsService = ServicesInitialiser.productsService;
ProductsDetailUC productsDetailUC = new ProductsDetailUC(errorMessageView);
ProductsDetailPresenter productsDetailPresenter = new ProductsDetailPresenter(productsDetailUC, facade);
ProductsPresenter productsPresenter = new ProductsPresenter(new ProductsUC(errorMessageView), productsDetailPresenter,
facade, deleteConfirmView, errorMessageView);
ParametersService parametersService = ServicesInitialiser.parametersService;
ParametersDetailUC parametersDetailUC = new ParametersDetailUC(errorMessageView);
ParametersDetailPresenter parametersDetailPresenter = new ParametersDetailPresenter(parametersDetailUC, facade);
ParametersPresenter parametersPresenter = new ParametersPresenter(new ParametersUC(errorMessageView),
parametersDetailPresenter, facade, deleteConfirmView, errorMessageView);
ImagesService imagesService = ServicesInitialiser.imagesService;
ImagesDetailUC imagesDetailUC = new ImagesDetailUC(errorMessageView);
ImagesDetailPresenter imagesDetailPresenter = new ImagesDetailPresenter(imagesDetailUC, facade);
ImagesPresenter imagesPresenter = new ImagesPresenter(new ImagesUC(errorMessageView), imagesDetailPresenter, ServicesInitialiser.facade, deleteConfirmView, errorMessageView);
GroupsService groupsService = ServicesInitialiser.groupsService;
GroupsDetailUC groupsDetailUC = new GroupsDetailUC(errorMessageView);
GroupsDetailPresenter groupsDetailPresenter = new GroupsDetailPresenter(groupsDetailUC, ServicesInitialiser.facade);
GroupsPresenter groupsPresenter = new GroupsPresenter(new GroupsUC(errorMessageView), groupsDetailPresenter, ServicesInitialiser.facade, deleteConfirmView, errorMessageView);
CategoriesService categoriesService = ServicesInitialiser.categoriesService;
CategoriesDetailUC categoriesDetailUC = new CategoriesDetailUC(errorMessageView);
CategoriesDetailPresenter categoriesDetailPresenter = new CategoriesDetailPresenter(categoriesDetailUC, facade);
CategoriesPresenter categoriesPresenter = new CategoriesPresenter(new CategoriesUC(errorMessageView), categoriesDetailPresenter, facade, deleteConfirmView, errorMessageView);
mainPresenter = new MainPresenter(mainView,
settingsPresenter,
unitsPresenter, unitsDetailPresenter,
suppliersPresenter, suppliersDetailPresenter,
productsPresenter, productsDetailPresenter,
parametersPresenter, parametersDetailPresenter,
imagesPresenter, imagesDetailPresenter,
groupsPresenter, groupsDetailPresenter,
categoriesPresenter, categoriesDetailPresenter,
facade, deleteConfirmView);
}
public FormAddSuppliers()
{
InitializeComponent();
_suppliersService = new SuppliersService();
_areaService = new AreaService();
_logService = new LogService();
_employeeService = new EmployeeService();
}
public SupplierEditForm(int supplierID)
{
InitializeComponent();
ctx = new BadgerDataModel();
_supplierService = new SuppliersService(ctx);
_supplierToEdit = _supplierService.Find(supplierID);
BindText();
}
public FormImportProductFormExcel()
{
InitializeComponent();
_suppliersService = new SuppliersService();
_productGroupService = new ProductGroupService();
_productService = new ProductService();
_stockService = new StockService();
_unitService = new UnitService();
_colorService = new ColorService();
}
public FormUpdateSuppliers(string supplierId)
{
InitializeComponent();
_suppliersService = new SuppliersService();
_areaService = new AreaService();
_employeeService = new EmployeeService();
_logService = new LogService();
_supplierId = supplierId;
GetSppliersById(supplierId);
}
public void CRUD_Suppliers()
{
IEnumerable<Supplier> suppliers = new SuppliersService(new DispatcherContext()).GetSuppliers();
//create
IEnumerable<City> cities = new SuppliersService(new DispatcherContext()).GetCities();
City city = cities.FirstOrDefault(c => c.Id == 3); //Sydney
Assert.IsNotNull(city);
Supplier supplier = new Supplier();
supplier.Name = "Inserted";
supplier.City = city;
supplier = new SuppliersService(new DispatcherContext()).SaveSupplier(supplier);
Assert.IsTrue(supplier.Id != 0);
Assert.IsNotNull(supplier.City);
//retrieve
supplier = new SuppliersService(new DispatcherContext()).GetSupplier(supplier.Id);
Assert.IsTrue(supplier.Name == "Inserted");
Assert.IsNotNull(supplier.City);
Assert.IsTrue(supplier.City.Id == city.Id);
//update
supplier.Name = "Updated";
new SuppliersService(new DispatcherContext()).SaveSupplier(supplier);
//retrieve
supplier = new SuppliersService(new DispatcherContext()).GetSupplier(supplier.Id);
Assert.IsTrue(supplier.Name == "Updated");
//delete
new SuppliersService(new DispatcherContext()).DeleteSupplier(supplier);
//retrieve
supplier = new SuppliersService(new DispatcherContext()).GetSupplier(supplier.Id);
Assert.IsNull(supplier);
}