protected List <DbProduct> Populate(DbContext advWorks, int numRows)
{
var list = new List <DbProduct>(numRows);
var productModel = advWorks.Set <DbProductModel>().First(p => p.ProductModelID == 15);
var productSet = advWorks.Set <DbProduct>();
var insertId = 2000;
for (var i = 0; i < numRows; i++)
{
var product = new DbProduct
{
ProductID = insertId++,
Name = "TEST_INSERTS",
DaysToManufacture = 5
};
productModel.Products.Add(product);
productSet.Add(product);
list.Add(product);
}
advWorks.SaveChanges();
return(list);
}
public async Task <IActionResult> Save(Guid id, string name, decimal price, int count, Guid categoryId)
{
var file = Request.Form.Files.FirstOrDefault();
byte[] imageData = null;
if (file != null)
{
using (var binaryReader = new BinaryReader(file.OpenReadStream()))
{
imageData = binaryReader.ReadBytes((int)file.Length);
}
}
var product = new DbProduct
{
Id = id,
Count = count,
Image = imageData,
Name = name,
Price = price,
CategoryId = categoryId,
};
await _productService.Save(product);
return(Redirect($"/Product/GetRegistry/{categoryId}"));
}
public void InconsistentAvailabilityShouldReturnNull()
{
// Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
var priceCalculator = new PriceCalculator(loggerMock.Object);
var dbProduct = new DbProduct
{
Availability = new List <Store>
{
new Store
{
Type = StoreType.Shop,
Price = 1000,
Quantity = 1,
},
new Store
{
Type = StoreType.Shop,
Price = 2000,
Quantity = 1,
}
}
};
// Act
(var price, var salePrice) = priceCalculator.GetPrice(dbProduct);
// Assert
Assert.IsNull(price);
Assert.IsNull(salePrice);
}
public async Task <DbProduct> Save(DbProduct product)
{
if (!_permissionService.HasPermissionToChangeProducts())
{
throw new InvalidOperationException("Нет прав доступа для изменения Товаров");
}
if (product.Id != Guid.Empty)
{
var existProuct = await _context.Products.Where(x => x.Id == product.Id).FirstOrDefaultAsync();
if (existProuct == null)
{
throw new InvalidOperationException("Позиция не найдена.");
}
Update(existProuct, product);
_context.Update(existProuct);
await _context.SaveChangesAsync();
return(existProuct);
}
product.OwnerId = Guid.Parse(_httpContextAccessor.HttpContext.User.Claims.First(c => c.Type == "UserId").Value);
_context.Products.Add(product);
await _context.SaveChangesAsync();
return(product);
}
public IActionResult Create([FromBody] ProductAddVM model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var fileDestDir = _env.ContentRootPath;
string dirName = _configuration.GetValue <string>("ImagesPath");
//Папка де зберігаються фотки
string dirPathSave = Path.Combine(fileDestDir, dirName);
if (!Directory.Exists(dirPathSave))
{
Directory.CreateDirectory(dirPathSave);
}
var bmp = model.Image.FromBase64StringToImage();
var imageName = Path.GetRandomFileName() + ".jpg";
string fileSave = Path.Combine(dirPathSave, $"{imageName}");
bmp.Save(fileSave, ImageFormat.Jpeg);
DbProduct p = new DbProduct
{
Name = model.Name,
Price = model.Price,
DateCreate = DateTime.Now
};
_context.Products.Add(p);
_context.SaveChanges();
return(Ok(p.Id));
}
public void TestCalculationAboveLowerBoundary()
{
// Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
var priceCalculator = new PriceCalculator(loggerMock.Object);
var dbProduct = new DbProduct
{
Availability = new List <Store>
{
new Store
{
Type = StoreType.Shop,
Price = 10000,
Quantity = 1,
}
}
};
// Act
(var price, var salePrice) = priceCalculator.GetPrice(dbProduct);
// Assert
Assert.AreEqual(10000, price);
Assert.AreEqual(9700, salePrice);
}
public void first_open()
{
food_list.Clear();
food_list = DbProduct.db_fill_FoodList("Main Menu");
fill_products();
panel_drinks.BackColor = Color.White;
panel_mainfoods.BackColor = Color.DarkOrange;
panel_desserts.BackColor = Color.White;
if (Seller.activeSeller != 0)
{
btn_product0_buy.Enabled = false;
btn_product1_buy.Enabled = false;
btn_product2_buy.Enabled = false;
}
else
{
btn_product0_buy.Enabled = true;
btn_product1_buy.Enabled = true;
btn_product2_buy.Enabled = true;
}
}
public (decimal?price, decimal?salePrice) GetPrice(DbProduct product)
{
if (product?.Availability?.Any() != true)
{
return(null, null);
}
var availability = product.Availability
.Where(a => a.Type == StoreType.Shop || a.Type == StoreType.Warehouse)
.Where(a => a.Quantity > 0)
.Where(a => a.Price > 0)
.ToList();
if (availability.Any() != true)
{
return(null, null);
}
var price = decimal.Round(availability.First().Price);
if (availability.All(s => s.Price == price) == false)
{
price = availability.Max(a => a.Price);
var prices = availability.Select(a => $"{a.Name}: {a.Price}");
_logger.LogInformation($"Prices are not equal in stores for {product.Name} - {product.Id}. {string.Join(", ", prices)}");
}
return(price, ApplyDiscount(price));
}
public Task <bool> AddIngredient(Guid recipeId, IIngredient ingredient)
{
return(Task.Run(() =>
{
using var context = new HomeAppDbContext(myDbOptions);
DbProduct product = context.Products.FirstOrDefault(p => p.Id.Equals(ingredient.ProductId));
if (product == null)
{
return false;
}
DbRecipe recipe = context.Recipes.FirstOrDefault(p => p.Id.Equals(recipeId));
if (product == null)
{
return false;
}
context.Ingredients.AddAsync(new DbIngredient
{
Product = product,
Recipe = recipe,
UnitQuantity = ingredient.UnitQuantity,
UnitQuantityType = ingredient.UnitQuantityType
});
context.SaveChanges();
return true;
}));
}
public async Task CanUpdateProductDescription()
{
// Arrange
var documentStoreProvider = DocumentStoreProvider;
var existingProduct = new DbProduct {
Name = "MyProduct", DescriptionMarkdown = "# Hello World!"
};
using (var session = documentStoreProvider.Store.OpenAsyncSession())
{
await session.StoreAsync(existingProduct, existingProduct.GetIdentifier());
}
// Act
var sut = new ProductManager(documentStoreProvider, logger);
await sut.InsertOrUpdateProductDescriptionAsync("MyProduct", "# MyProduct");
// Assert
using (var session = documentStoreProvider.Store.OpenAsyncSession())
{
var product = await session.LoadAsync <DbProduct>(existingProduct.GetIdentifier());
product.ShouldNotBeNull();
product.DescriptionMarkdown.ShouldBe("# MyProduct");
}
}
public async Task GetsProductDescription()
{
// Arrange
var documentStoreProvider = DocumentStoreProvider;
using (var session = documentStoreProvider.Store.OpenAsyncSession())
{
var product = new DbProduct
{
Name = "MyProduct",
DescriptionMarkdown = "# Hello World!",
};
await session.StoreAsync(product);
await session.SaveChangesAsync();
}
WaitForIndexing(documentStoreProvider.Store);
// Act
var sut = new ProductManager(documentStoreProvider, logger);
var result = await sut.GetProductDescriptionAsync("MyProduct");
// Assert
result.ShouldNotBeNull();
result.ShouldBe("# Hello World!");
}
public void Pay(string id)
{
DbProduct product = DbProductFactory.Create();
string productData = product.GetProductById(id);
Console.WriteLine(productData);
}
private bool ProductEquals(WcProduct wcProduct, DbProduct dbProduct)
{
return
(wcProduct.StockStatus == dbProduct.GetStockStatus() &&
wcProduct.Availability == dbProduct.GetAvailability() &&
ProductPriceEquals(wcProduct, dbProduct));
}
public IActionResult Delete(int id)
{
DbProduct prod = _context.Products.Where(p => p.Id == id).FirstOrDefault();
_context.Products.Remove(prod);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
private void btn_add_Click(object sender, EventArgs e)
{
Product product = new Product();
product = fill_product_data_from_Form(product);
DbProduct.db_addNewProduct(product);
this.Close();
}
public void AddProductDb()
{
var dbProduct = new DbProduct();
var product = new Product("The product name", 23.45m, "The product description", "The product catagory", "Img path");
var flag = dbProduct.AddProduct(product);
Assert.AreNotEqual(0, flag);
}
// Удаление позиций
private static void DeletePositions()
{
var doc = AcApp.DocumentManager.MdiActiveDocument;
var ed = doc.Editor;
var db = HostApplicationServices.WorkingDatabase;
var opts = new PromptSelectionOptions
{
MessageForAdding = $"\n{Language.GetItem(LangItem, "h5")}: "
};
var res = ed.GetSelection(opts);
if (res.Status != PromptStatus.OK)
{
return;
}
using (var tr = db.TransactionManager.StartTransaction())
{
try
{
foreach (var objectId in res.Value.GetObjectIds())
{
var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);
// Расширенные данные в виде спец.класса
var productInsert = (MpProductToSave)XDataHelpersForProducts.NewFromEntity(ent);
if (productInsert == null)
{
continue;
}
// Теперь получаем сам продукт
var product = DbProduct.GetProductFromSaved(productInsert);
// Если есть данные и нет позиции
if (product != null)
{
product.Position = string.Empty;
XDataHelpersForProducts.SaveDataToEntity(product.SetProductToSave(), ent, tr);
}
}
}
catch (Exception ex)
{
ExceptionBox.Show(ex);
}
finally
{
// В любом случае убираем подсветку со всех объектов
foreach (var objectId in res.Value.GetObjectIds())
{
var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);
ent.Unhighlight();
}
tr.Commit();
}
}
}
private void pictureBox_desserts_Click(object sender, EventArgs e)
{
panel_drinks.BackColor = Color.White;
panel_mainfoods.BackColor = Color.White;
panel_desserts.BackColor = Color.DarkOrange;
food_list = DbProduct.db_fill_FoodList("Desserts");
index_of_foodlist = 1;
fill_products();
}
private void Update(DbProduct oldProduct, DbProduct newProduct)
{
oldProduct.Count = newProduct.Count;
oldProduct.Image = newProduct.Image;
oldProduct.Name = newProduct.Name;
oldProduct.Price = newProduct.Price;
oldProduct.CategoryId = newProduct.CategoryId;
oldProduct.OwnerId = Guid.Parse(_httpContextAccessor.HttpContext.User.Claims.First(c => c.Type == "UserId").Value);
}
/// <summary>
/// Инициализация экземпляра <see cref="SpecificationItem"/> по экземпляру <see cref="DbProduct"/>
/// </summary>
/// <param name="product">Экземпляр <see cref="DbProduct"/>, связанный с позицией спецификации</param>
/// <param name="steelDoc">Документ на сталь</param>
/// <param name="steelType">Тип стали</param>
/// <param name="dimension">Вариант измерения</param>
public SpecificationItem(
DbProduct product,
string steelDoc,
string steelType,
string dimension)
{
Product = product;
Dimension = dimension;
InputType = SpecificationItemInputType.DataBase;
InitSpecificationItem(steelDoc, steelType);
}
private async Task PrepareImage(ProductUpdateRequestDto model, DbProduct create)
{
if (model.Image != null && model.Image.Id == null)
{
var dbModel = _mapper.Map <DbImage>(model.Image);
dbModel.Buffer = Convert.FromBase64String(model.Image.Base64String);
var dbImage = await _imageRepository.Add(dbModel);
create.ImageId = dbImage.Id;
}
}
private DbProduct SetProductData(AddEditProduct productFromView)
{
DbProduct newDbProduct = new DbProduct();
newDbProduct.DbProductId = String.IsNullOrEmpty(productFromView.ProductId) ? GeneratorId.GenerateId() : productFromView.ProductId;
newDbProduct.DbProductName = productFromView.ProductName;
newDbProduct.DbProductWeight = Decimal.Parse(productFromView.ProductWeight.Replace(".", ","));
newDbProduct.DbProductCategory = (int)CategoryConverter.RusStringToEnum(productFromView.ProductCategory);
newDbProduct.DbImageRes = productFromView.ProductImageRes;
return(newDbProduct);
}
public void TestConcurrencyLessThenMaxAmount()
{
var i1 = 0;
var i2 = 0;
var prod = new Product("TestProd1", new decimal(10), "TestDescription", "Oste", "TestPath");
var s = new Shop("TestShop1", "TestAddress", "12345678", "OpeningTime", new DbChain().GetChain(1), new List <Warehouse>());
//add product to database
int prodId = new DbProduct().AddProduct(prod);
prod.Id = prodId;
//add shop to database
var shopId = new DbShop().AddShop(s);
s.Id = shopId;
//add warehouse to databse and add it to shop
var warehouse = new Warehouse(10, 0, prod, s, null);
var warId = new DbWarehouse().AddWarehouse(warehouse);
warehouse.Id = warId;
s.Warehouses.Add(warehouse);
//make cart1 with part order
var cart1 = new Cart();
var po1 = new PartOrder(prod, 5, 20);
cart1.PartOrders.Add(po1);
cart1.PersonId = _cust.Id;
cart1.ShopId = s.Id;
//make cart2 with part order
var cart2 = new Cart();
var po2 = new PartOrder(prod, 2, 20);
cart2.PartOrders.Add(po2);
cart2.PersonId = _cust1.Id;
cart2.ShopId = s.Id;
//start 2 parallel queries
var cartDb = new DbCart();
Parallel.Invoke(() => { i1 = cartDb.AddCartWithPartOrders(cart1); }, () => { i2 = cartDb.AddCartWithPartOrders(cart2); });
//var antal = new DbWarehouse().GetWarehouse(warId).Stock;
var flag = 0;
if (i1 == 0 || i2 == 0)
{
flag = 1;
}
Assert.AreEqual(1, flag);
}
public ProductDetail(int product_id)
{
InitializeComponent();
product = DbProduct.get_product_from_id(product_id);
fill_product_details();
if (Seller.activeSeller != 0) //satıcı hesabi ise satın al butonlarını göremesini engelliyoruz
{
btn_buy.Enabled = false;
btn_GivePoint.Enabled = false;
}
fill_comments();
}
private void loadProducts()
{
List <Category> categories = DbProduct.GetCategories();
categories.Add(new Category(-1, Application.Current.Resources["cNone"] as String));
PFCat.ItemsSource = categories;
PFCat.DisplayMemberPath = "Title";
Data.Products = DbProduct.GetProducts();
dgProducts.ItemsSource = Data.Products;
bAddProduct.IsEnabled = true;
}
public IActionResult Create([FromBody] ProductCreateVM model)
{
DbProduct product = new DbProduct
{
CategoryId = model.CategoryId,
Name = model.Name,
Price = model.Price,
Image = model.Image
};
_context.Products.Add(product);
_context.SaveChanges();
return(Ok(product));
}
public void SetUp()
{
DefaultWcProduct = new WcProduct
{
Availability = "test",
Sku = "0",
RegularPrice = 0,
SalePrice = 0,
StockStatus = "instock",
};
DefaultDbProduct = new DbProduct
{
Id = 0,
Availability = new List <Store>
{
new Store
{
Name = "test",
Quantity = 1,
Price = 0,
Type = StoreType.Shop,
}
}
};
_wcProductServiceMock = new Mock <IWcProductService>();
_wcProductServiceMock
.Setup(m => m.GetProductsAsync())
.Returns(Task.FromResult(new List <WcProduct> {
DefaultWcProduct
}));
_dbProductRepositoryMock = new Mock <IDbProductRepository>();
_dbProductRepositoryMock
.Setup(r => r.GetProducts())
.Returns(new List <DbProduct> {
DefaultDbProduct
});
var loggerMock = new Mock <ILogger <ProductService> >();
_productService = new ProductService(
_wcProductServiceMock.Object,
_dbProductRepositoryMock.Object,
new PriceCalculator(loggerMock.Object),
loggerMock.Object);
}
public ActionResult Print(HttpPostedFileBase file)
{
if (file != null && file.ContentLength > 0)
{
var dto = DeliverySerializer.LoadFromStream(file.InputStream);
Dictionary <string, int> titleArray = new Dictionary <string, int>();
using (var db = new ApplicationDbContext())
{
var row = new DbDeliveryRquest
{
ClientAddress = dto.ClientAddress,
Filled = dto.Filled,
TimeDeliver = dto.TimeDeliver,
TotalCost = dto.TotalCost,
FullName = dto.FullName
};
row.WayPoints = new Collection <DbWayPoint>();
foreach (var wpDto in dto.WayPoints)
{
var wp = new DbWayPoint
{
Address = wpDto.Address,
PlaceTitle = wpDto.PlaceTitle,
ShopType = wpDto.ShopType,
};
row.WayPoints.Add(wp);
wp.ProductsList = new Collection <DbProduct>();
foreach (var product in wpDto.ProductsList)
{
var p = new DbProduct
{
Name = product.Name,
Amount = product.Amount,
Additions = product.Additions,
Cost = product.Cost,
};
wp.ProductsList.Add(p);
}
db.productList.AddRange(wp.ProductsList);
}
db.DeliveryRequest.Add(row);
db.SaveChanges();
return(View(dto));
}
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Inserts or updates the provided description for the product with the provided name.
/// </summary>
/// <param name="productName">The name of the product for which the description should be persisted.</param>
/// <param name="descriptionMarkdown">The description that should be persisted.</param>
public async Task InsertOrUpdateProductDescriptionAsync(string productName, string descriptionMarkdown)
{
var dbProduct = new DbProduct()
{
Name = productName,
DescriptionMarkdown = descriptionMarkdown
};
using (var session = _storeProvider.Store.OpenAsyncSession())
{
// Using the store method when the product already exists in the database will override it completely, this is acceptable
await session.StoreAsync(dbProduct, dbProduct.GetIdentifier());
await session.SaveChangesAsync();
}
}
//Pay meu metodo de nivel alto. Onde estão as regras de negocio
public void Pay(string id)
{
//Dependendo de uma classe de nivel BAIXO. SQL Server. Não é a regra de negocio.
//Nessa refatoração vamos criar uma configuração
//Vamos utilizar também a abstração e vamos usar factory.
//Agora na classe de pagamento não vou depender de uma classe de baixo nivel.
//Vamos ter uma dependencia de abstração. Não importa qual banco.
//Vamos usar a factory do produto
//SQLServerProduct product = new SQLServerProduct();
DbProduct product = DbProductFactory.Create();
string productData = product.GetProductById(id);
Console.WriteLine(productData);
}
