public int AddProduct(ProductBO product)
{
try
{
List <ProductDescription> descr = new List <ProductDescription>();
Product prod = new Product();
prod.ProductName = product.ProductName;
prod.ProductDescription = product.ProductDescription;
foreach (var item in product.DescriptionBO)
{
ProductDescription desc = new ProductDescription();
desc.Size = item.Size;
desc.UnitPrice = item.UnitPrice;
desc.QualityType = item.QualityType;
desc.Discount = item.Discount;
descr.Add(desc);
}
prod.ProductDescriptions = descr;
_db.Products.Add(prod);
_db.SaveChanges();
return(prod.ProductID);
}
catch (Exception ex)
{
throw ex;
}
}
private bool CalcaluteProductReadyForWehkamp(Product p, ProductDescription productDescription, IServiceUnitOfWork unit, VendorAssortment vendorAT)
{
//check for product descriptions
if (!ReadyforWehkampProductDescription(productDescription, p.ProductID, unit))
{
return(false);
}
//check for materialdescription attribute
if (!ReadyForWehkampAttributes(p, MaterialDescriptionAttributeID))
{
return(false);
}
//check for attribute option material
if (!ReadyForWehkampAttributes(p, MaterialAttributeID))
{
return(false);
}
if (vendorAT != null)
{
//check (only for AT) attribute option dessin
if (!ReadyForWehkampAttributes(p, DessinAttributeID))
{
return(false);
}
}
return(true);
}
public async Task <IActionResult> PutProductDescription([FromRoute] int id, [FromBody] ProductDescription productDescription)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != productDescription.ProductDescriptionId)
{
return(BadRequest());
}
_context.Entry(productDescription).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductDescriptionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PostProductDescription(ProductDescriptionModel productDescriptionModel)
{
try
{
var productDescription = new ProductDescription()
{
Title = productDescriptionModel.ProductName,
CategoryName = productDescriptionModel.ProductCategory,
AuthorName = productDescriptionModel.AuthorName,
AuthorDescription = productDescriptionModel.AuthorDescription,
AuthorImage = productDescriptionModel.AuthorImageValue,
ProductSummary = productDescriptionModel.ProductSummary,
PublisherName = productDescriptionModel.PublisherName,
Edition = productDescriptionModel.Edition,
NumOfPages = productDescriptionModel.NumofPages,
Country = productDescriptionModel.Country,
Language = productDescriptionModel.Language,
ProductId = productDescriptionModel.ProductId
};
await _context.ProductDescriptions.AddAsync(productDescription);
await _context.SaveChangesAsync();
return(Ok(productDescription));
}
catch (Exception ex)
{
throw ex;
}
}
private ProductDescription GetProductType(Warehouse location)
{
ProductDescription _ret = new ProductDescription(ProductType.Other, false);
if (location == null)
{
return(_ret);
}
switch (location.ProductType)
{
case ProductType.Tobacco:
_ret = new ProductDescription(ProductType.Tobacco, false);
break;
case ProductType.IPRTobacco:
_ret = new ProductDescription(ProductType.IPRTobacco, true);
break;
case ProductType.Invalid:
case ProductType.Cutfiller:
case ProductType.Cigarette:
case ProductType.Other:
default:
break;
}
return(_ret);
}
public void FromDataBase(ProductModelProductDescription model)
{
ProductModelID = model.ProductModelID;
ProductDescriptionID = model.ProductDescriptionID;
Culture = model.Culture;
rowguid = model.rowguid;
ModifiedDate = model.ModifiedDate;
try
{
ProductDescription = new ProductDescription()
{
ProductDescriptionID = model.ProductDescription.ProductDescriptionID,
Description = model.ProductDescription.Description,
rowguid = model.ProductDescription.rowguid,
ModifiedDate = model.ProductDescription.ModifiedDate
};
ProductModel = new ProductModel()
{
ProductModelID = model.ProductModel.ProductModelID,
Name = model.ProductModel.Name,
CatalogDescription = model.ProductModel.CatalogDescription,
rowguid = model.ProductModel.rowguid,
ModifiedDate = model.ProductModel.ModifiedDate
};
}
catch (Exception ex)
{
}
}
void ProductsLoaded()
{
var descList = new List <ProductDescription>(this.productsList.Count);
foreach (var product in this.productsList)
{
string priceString;
float price = product.MicrosPrice * 0.000001f;
if (price < 100)
{
priceString = price.ToString("0.00");
}
else
{
priceString = ((int)(price + 0.5f)).ToString();
}
var prodMeta = new ProductMetadata(priceString, product.ProductName, product.ProductDesc, product.Currency, (decimal)price);
ProductDescription prodDesc;
if (this.purchasedData.TryGetValue(product.ProductId, out var purchaseData))
{
prodDesc = new ProductDescription(product.ProductId, prodMeta, CreateReciept(purchaseData), purchaseData.OrderID);
}
else
{
prodDesc = new ProductDescription(product.ProductId, prodMeta);
}
descList.Add(prodDesc);
}
this.storeEvents.OnProductsRetrieved(descList);
}
private void OnProductsRetrieved(Result result)
{
this.products = new Dictionary <string, ProductDescription>();
if (!result.IsSucceeded)
{
OnSetupFailed(result.Error.Code + ", " + result.Error.Message);
return;
}
List <IOSProductTemplate> list = IOSInAppPurchaseManager.Instance.Products;
string globalId = null;
string storeId = null;
for (int i = 0; i < list.Count; i++)
{
storeId = list[i].Id;
globalId = IAPManager.GetIAPIdentifier(storeId);
if (!products.ContainsKey(globalId))
{
products.Add(globalId, new ProductDescription(storeId, new ProductMetadata(list[i].LocalizedPrice,
list[i].DisplayName, list[i].Description,
list[i].CurrencyCode, (decimal)list[i].Price)));
}
if (PlayerPrefs.HasKey(globalId))
{
products[globalId] = new ProductDescription(storeId, products[globalId].metadata, DBManager.GetReceipt(globalId), "");
}
}
callback.OnProductsRetrieved(products.Values.ToList());
}
private void AddProductDescriptions(Product product, ProductViewModel sfProduct)
{
var displayName = sfProduct.Item.Title;
var shortDescription = sfProduct.Item.Description;
var longDescription = sfProduct.Item.Description;
var desc = new ProductDescription
{
CultureCode = sfProduct.CultureCode,
DisplayName = displayName,
ShortDescription = shortDescription,
LongDescription = longDescription
};
foreach (var translation in sfProduct.CultureTranslations)
{
var productDescription = new ProductDescription()
{
CultureCode = translation.Key,
DisplayName = translation.Value.Item.Title,
ShortDescription = translation.Value.Item.Description,
LongDescription = translation.Value.Item.Description,
Product = product
};
product.AddProductDescription(productDescription);
}
product.AddProductDescription(desc);
}
public override void Init(object[] inputs)
{
mManager = (AFramework.IAP.IAPManager)inputs[0];
mSystem = this.gameObject.AddComponent <Sdkbox.IAP>();
mSystem.androidKey = (string)inputs[1];
var hackConstructor = typeof(Sdkbox.IAP.Callbacks).GetConstructor(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new System.Type[] { }, null);
mSystem.callbacks = (Sdkbox.IAP.Callbacks)hackConstructor.Invoke(null);
mSystem.iOSProducts = new List <ProductDescription>();
mSystem.androidProducts = new List <ProductDescription>();
var currentPackage = mManager.CurrentPackages;
foreach (var pair in currentPackage)
{
var data = pair.Value;
var item = new ProductDescription();
item.id = data.Identifier;
item.name = data.Identifier;
item.consumable = data.Type == eProductType.Consumable;
#if UNITY_IOS
mSystem.iOSProducts.Add(item);
#else
mSystem.androidProducts.Add(item);
#endif
}
mSystem.callbacks.onProductRequestSuccess.AddListener(SdkboxProductRequestSuccess);
mSystem.callbacks.onRestored.AddListener((product) => { PurchaseSucceeded(product.id); });
mSystem.callbacks.onCanceled.AddListener((product) => { PurchaseFailed("Cancel"); });
mSystem.callbacks.onFailure.AddListener((product, str) => { PurchaseFailed(str); });
}
public async Task <IActionResult> UpdateProductDescription(int id, [FromBody] ProductDescription productDescription)
{
_logger?.LogDebug($"Method '{nameof(UpdateProductDescription)}' ID: {id}, new description: '{productDescription.Description}' called.");
if (id < 0)
{
return(BadRequest("Bad ID"));
}
try
{
var productToUpdate = await _productService.GetProductById(id);
if (productToUpdate == null)
{
return(NotFound());
}
await _productService.UpdateDescription(productToUpdate, productDescription.Description);
_logger?.LogInformation($"Method '{nameof(UpdateProductDescription)}' ID: {id} successfully done.");
return(NoContent());
}
catch (Exception ex)
{
_logger?.LogCritical($"Method '{nameof(UpdateProductDescription)}' ID: {id} error: {ex.Message}.");
throw;
}
}
/// <summary>
/// Adds the product.
/// </summary>
/// <param name="product">The product.</param>
/// <param name="productDescription">The product description.</param>
/// <param name="productPhoto">The product photo.</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task EditProduct(Product product, ProductDescription productDescription, ProductPhoto productPhoto)
{
using (var transaction = await _context.Database.BeginTransactionAsync())
{
try
{
_context.Product.Update(product);
await _context.SaveChangesAsync();
if (productDescription != null)
{
_context.ProductDescription.Update(productDescription);
await _context.SaveChangesAsync();
}
if (productPhoto != null)
{
_context.ProductPhoto.Update(productPhoto);
await _context.SaveChangesAsync();
}
// Commit transaction if all commands succeed, transaction will auto-rollback
// when disposed if either commands fails
transaction.Commit();
}
catch (Exception e)
{
throw e.InnerException;
}
}
}
public override Product LoadProduct()
{
try
{
string productCode = this._htmlDoc.DocumentNode.QuerySelector(".product-code-display.pull-left").InnerText.Replace("Termékkód: ", "").Trim();
string title = _htmlDoc.DocumentNode.QuerySelector(".page-title").InnerText.ToLower().Trim();
string brand = ""; //IMPLEMENT THIS
string model = ""; //IMPLEMENT THIS
int oldPrice = Convert.ToInt32(_htmlDoc.DocumentNode
.SelectSingleNode(".//p[@class = 'product-old-price']/s").InnerText.Replace("\n", "").Replace(".", "").Replace(" Ft", "").Trim());
int newPrice = Convert.ToInt32(_htmlDoc.DocumentNode
.SelectSingleNode(".//p[@class = 'product-new-price']").InnerText.Replace("\n", "").Replace(".", "").Replace(" Ft", "").Trim());
int sale = Convert.ToInt32(Regex.Replace(_htmlDoc.DocumentNode.SelectSingleNode(".//span[@class = 'product-this-deal']").InnerText, "[^0-9]", ""));
int nrOfReviews = LoadNrOfReviewsPropertyOfProduct(_htmlDoc);
double starsAverage = LoadStarsAveragePropertyOfProduct(_htmlDoc);
List <ProductDetail> productDetails = GetProductDetails();
ProductDescription productDescription = GetProductDescription();
List <ProductReview> productReviews = GetProductReviews();
List <ProductImage> productImages = GetProductImages();
//Console.WriteLine(Product.ToString());
Product = new Product(productCode, webshopName: "EMAG", title, brand, model, oldPrice, newPrice, sale, nrOfReviews, starsAverage, this.ProductPageLink, productDescription,
productDetails, productReviews, productImages, this.CategoryName, this.CategoryLink);
return(Product);
}
catch (ArgumentException)
{
throw new ArgumentException("Ran into an error while creating the product");
}
}
private ProductDescription GetProductDescription()
{
try
{
ProductDescription productDescription = new ProductDescription();
string Description = string.Empty;
int NumberOfPicturesInDescription = 0;
string[] Images = new string[NumberOfPicturesInDescription];
var descriptionNode = _htmlDoc.DocumentNode.SelectSingleNode(".//div[@class ='product-page-description-text']");
foreach (var p in descriptionNode.SelectNodes(".//p"))
{
string pInnerText = p.InnerHtml;
if (pInnerText.Contains("\n"))
{
pInnerText = p.InnerHtml.Replace("\n", "").Trim();
}
Description += pInnerText;
}
return(productDescription);
}
catch
{
throw new ArgumentException("Ran into an error while creating the product description");
}
}
public void InsertProductPerformanceTest()
{
int nProducts = 50;
int avgProductPlugins = 30;
var store = new PluginStore();
Version vers01 = new Version(0, 1);
Stopwatch stopWatch = new Stopwatch();
Random r = new Random();
var plugins = store.Plugins.ToList();
stopWatch.Start();
// create products
for (int i = 0; i < nProducts; i++)
{
string name = RandomName();
List <PluginDescription> prodPlugins = new List <PluginDescription>();
for (int j = 0; j < avgProductPlugins; j++)
{
var selectedPlugin = plugins[r.Next(0, plugins.Count)];
if (!prodPlugins.Contains(selectedPlugin))
{
prodPlugins.Add(selectedPlugin);
}
}
var prod = new ProductDescription(name, vers01, prodPlugins);
store.Persist(prod);
}
stopWatch.Stop();
Assert.Inconclusive("Created " + nProducts + " products in " + stopWatch.ElapsedMilliseconds +
" ms (" + (double)stopWatch.ElapsedMilliseconds / nProducts + " ms / product )");
}
/// <summary>
/// Deep load all ProductDescription children.
/// </summary>
private void Step_03_DeepLoad_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
int count = -1;
mock = CreateMockInstance(tm);
mockCollection = DataRepository.ProductDescriptionProvider.GetPaged(tm, 0, 10, out count);
DataRepository.ProductDescriptionProvider.DeepLoading += new EntityProviderBaseCore <ProductDescription, ProductDescriptionKey> .DeepLoadingEventHandler(
delegate(object sender, DeepSessionEventArgs e)
{
if (e.DeepSession.Count > 3)
{
e.Cancel = true;
}
}
);
if (mockCollection.Count > 0)
{
DataRepository.ProductDescriptionProvider.DeepLoad(tm, mockCollection[0]);
System.Console.WriteLine("ProductDescription instance correctly deep loaded at 1 level.");
mockCollection.Add(mock);
// DataRepository.ProductDescriptionProvider.DeepSave(tm, mockCollection);
}
//normally one would commit here
//tm.Commit();
//IDisposable will Rollback Transaction since it's left uncommitted
}
}
///<summary>
/// Returns a Typed ProductModelProductDescriptionCulture Entity with mock values.
///</summary>
static public ProductModelProductDescriptionCulture CreateMockInstance_Generated(TransactionManager tm)
{
ProductModelProductDescriptionCulture mock = new ProductModelProductDescriptionCulture();
mock.ModifiedDate = TestUtility.Instance.RandomDateTime();
//OneToOneRelationship
Culture mockCultureByCultureId = CultureTest.CreateMockInstance(tm);
DataRepository.CultureProvider.Insert(tm, mockCultureByCultureId);
mock.CultureId = mockCultureByCultureId.CultureId;
//OneToOneRelationship
ProductDescription mockProductDescriptionByProductDescriptionId = ProductDescriptionTest.CreateMockInstance(tm);
DataRepository.ProductDescriptionProvider.Insert(tm, mockProductDescriptionByProductDescriptionId);
mock.ProductDescriptionId = mockProductDescriptionByProductDescriptionId.ProductDescriptionId;
//OneToOneRelationship
ProductModel mockProductModelByProductModelId = ProductModelTest.CreateMockInstance(tm);
DataRepository.ProductModelProvider.Insert(tm, mockProductModelByProductModelId);
mock.ProductModelId = mockProductModelByProductModelId.ProductModelId;
// create a temporary collection and add the item to it
TList <ProductModelProductDescriptionCulture> tempMockCollection = new TList <ProductModelProductDescriptionCulture>();
tempMockCollection.Add(mock);
tempMockCollection.Remove(mock);
return((ProductModelProductDescriptionCulture)mock);
}
public async Task <IActionResult> PatchProduct(int id, ProductDescription description)
{
Product product = await _context.Products.FindAsync(id);
if (product == null)
{
return(NotFound());
}
product.Description = description.Description;
_context.Entry(product).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
///<summary>
/// Update the Typed ProductDescription Entity with modified mock values.
///</summary>
static public void UpdateMockInstance(TransactionManager tm, ProductDescription mock)
{
ProductDescriptionTest.UpdateMockInstance_Generated(tm, mock);
// make any alterations necessary
// (i.e. for DB check constraints, special test cases, etc.)
SetSpecialTestData(mock);
}
public void ShouldBeValid_WhenNameIsValid(string name)
{
var actual = ProductDescription.TryCreate(name);
Check.That(actual)
.IsEqualTo(
Validation.Valid(new ProductDescription(name)));
}
//ProductApi/Product
public string PostProduct(ProductDescription p)
{
p.rowguid = Guid.NewGuid();
p.ModifiedDate = DateTime.Now;
db.ProductDescriptions.Add(p);
db.SaveChanges();
return("Success");
}
public async Task CreateDescription(ProductDescription description)
{
description.CreationDate = DateTime.Now;
description.EditDate = DateTime.Now;
await _productDescriptionRepository.Add(description);
await _productDescriptionRepository.SaveChangesAsync();
}
private void ClearProductEditSection()
{
OwnerCombo.SelectedItem = null;
StatusDescriptionCombo.SelectedItem = null;
ProductTypeCombo.SelectedItem = null;
ZoneDescriptionCombo.SelectedItem = null;
ProductDescription.Clear();
_mainWindowViewController.NewProduct();
}
public ProductDescription1(int val)
{
EntityManager<ProductDescription> mgrproduct = new EntityManager<ProductDescription>();
ProductDescription p_dd = new ProductDescription();
//p_d.ProductDescriptionID = 4;
p_dd.ProductDescriptionID = val;
List<ProductDescription> list1 = mgrproduct.Search(p_dd);
Textbox1.Text = list1[0].Description.ToString();
}
private void NewButton_Click(object sender, RoutedEventArgs e)
{
OwnerCombo.SelectedItem = null;
StatusDescriptionCombo.SelectedItem = null;
ProductTypeCombo.SelectedItem = null;
ZoneDescriptionCombo.SelectedItem = null;
ProductDescription.Clear();
_mainWindowViewController.NewProduct();
}
public ActionResult Add(ProductDescription obj)
{
Thread.Sleep(3000);
obj.rowguid = Guid.NewGuid();
obj.ModifiedDate = DateTime.Now;
db.ProductDescriptions.Add(obj);
db.SaveChanges();
return(View());
}
public void ShouldBeInvalid_WhenEmpty(string name)
{
var actual = ProductDescription.TryCreate(name);
Check.That(actual)
.IsEqualTo(
Validation.Invalid <ProductDescription>(
new ProductDescription.EmptyValidationError()));
}
public void TestProductDescription()
{
var prod1 = new ProductDescription("testID", metadata);
Assert.AreEqual(prod1.storeSpecificId, "testID");
Assert.AreEqual(prod1.type, ProductType.Consumable);
Assert.AreEqual(prod1.metadata, metadata);
Assert.That(prod1.receipt, Is.Null);
Assert.That(prod1.transactionId, Is.Null);
}
/// <summary>
/// Constructor for a product
/// </summary>
/// <param name="title"></param>
/// <param name="primaryCategory"></param>
/// <param name="topLevelCategory"></param>
/// <param name="categoryPath"></param>
/// <param name="skus"></param>
/// <param name="description"></param>
public Product(String title, Int32 primaryCategory, Int32 topLevelCategory, String categoryPath, SKU[] skus, ProductDescription description)
: this()
{
this.SKUs = skus;
this.Description = description;
this.Title = title;
this.PrimaryCategory = primaryCategory;
this.TopLevelCategory = topLevelCategory;
this.CategoryPath = categoryPath;
}
public void Edit(ProductDescription productDescription)
{
ProductDescription editProductDescription = context.ProductDescription.Find(productDescription.Id);
editProductDescription.Name = productDescription.Name;
editProductDescription.Text = productDescription.Text;
editProductDescription.IsShort = productDescription.IsShort;
editProductDescription.ProductId = productDescription.ProductId;
context.SaveChanges();
}
/// <summary>
/// Check the foreign key dal methods.
/// </summary>
private void Step_10_FK_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
ProductDescription entity = CreateMockInstance(tm);
bool result = DataRepository.ProductDescriptionProvider.Insert(tm, entity);
Assert.IsTrue(result, "Could Not Test FK, Insert Failed");
}
}
public ActionResult Edit([Bind(Include = "ProductDescriptionID,Description,rowguid,ModifiedDate,isDeleted")] ProductDescription productDescription)
{
if (ModelState.IsValid)
{
db.Entry(productDescription).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(productDescription));
}
// PUT api/awbuildversion/5
public void Put(ProductDescription value)
{
var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault();
if (GetActionType.Key != null)
{
if (GetActionType.Value.ToList()[0].Equals("DELETE"))
adventureWorks_BC.ProductDescriptionDelete(value);
if (GetActionType.Value.ToList()[0].Equals("UPDATE"))
adventureWorks_BC.ProductDescriptionUpdate(value);
}
}
public ProductDescription AddProductDescription(decimal basePrice, string description, bool gstFree)
{
var pd = new ProductDescription(this, basePrice, description, gstFree);
if (ProductDescriptions.Contains(pd))
{
throw new Exception(" Product already exists");
}
ProductDescriptions.Add(pd);
return pd;
}
public void ContructorFromXmlTest()
{
string xml = @"<?xml version='1.0' encoding='UTF-8'?>
<Description>
<ArbitraryXml1><Whoa>There</Whoa></ArbitraryXml1>
<ArbitraryXml2><Whoa>There</Whoa></ArbitraryXml2>
<Summary>
<![CDATA[
This is a summary it can contain HTML markup.
To tell the translation service to ignore some
text, <b>wrap</b> it in a
[do-not-translate]
do not translate
[/do-not-translate]
tag
]]>
</Summary>
<Features>
<Feature1>Feature 1 & Bold</Feature1>
<Feature2>Feature 2</Feature2>
</Features>
</Description>
";
XDocument document = XDocument.Parse(xml);
var description = new ProductDescription(document.Element("Description"));
Assert.AreEqual(Regex.Replace(@"This is a summary it can contain HTML markup.
To tell the translation service to ignore some
text, <b>wrap</b> it in a
[do-not-translate]
do not translate
[/do-not-translate]
tag", @"\s", ""), Regex.Replace(description.Summary, @"\s", ""));
XElement[] arbitrary = new XElement[] { XElement.Parse("<ArbitraryXml1><Whoa>There</Whoa></ArbitraryXml1>"), XElement.Parse("<ArbitraryXml2><Whoa>There</Whoa></ArbitraryXml2>") };
Dictionary<String, String> features = new Dictionary<String, String>() { {"Feature1", "Feature 1 & Bold"}, {"Feature2", "Feature 2"} };
for (int i = 0; i < arbitrary.Length; i++)
{
Assert.AreEqual(arbitrary[i].ToString(SaveOptions.None), description.ArbitraryElements[i].ToString(SaveOptions.None));
}
foreach (string featureKey in features.Keys)
{
Assert.AreEqual(features[featureKey], description.Features[featureKey]);
}
}
public void ProductConstructorTest()
{
String title = "Title";
Int32 primaryCategory = 5;
Int32 topLevelCategory = 10;
String categoryPath = "Some Path";
SKU[] skus = new SKU[5];
var features = new Dictionary<String, String>() {{"F1", "V1"}, {"F2", "V2"}, {"F3", "V3"}};
ProductDescription description = new ProductDescription(arbitraryElements: null, features: features);
Product product = new Product(title, primaryCategory, topLevelCategory, categoryPath, skus, description);
Assert.AreEqual(product.Title, title);
Assert.AreEqual(product.PrimaryCategory, primaryCategory);
Assert.AreEqual(product.TopLevelCategory, topLevelCategory);
Assert.AreEqual(product.CategoryPath, categoryPath);
Assert.AreEqual(product.SKUs.Count, skus.Length);
Assert.AreEqual(product.Description.Features.Count, features.Count);
}
partial void InsertProductDescription(ProductDescription instance);
public void SaveToProductDescription(ProductDescription productDescription)
{
_context.Entry(productDescription).State = (EntityState) (productDescription.ProductDescriptionID == 0 ? EntityState.Added : EntityState.Modified);
_context.SaveChanges();
}
//Если продукт новый, то нужно добавить ему описание и все это дело связать с моделью
public ActionResult CreateProductDescription(int productId, int productModelId)
{
var product = _repository.Products.FirstOrDefault(x => x.ProductID == productId);
var productModel =
_productModelRepository.ProductModels.FirstOrDefault(x => x.ProductModelID == productModelId); //модель
var productDescription = new ProductDescription { Description = String.Empty, ModifiedDate = DateTime.Now, rowguid = Guid.NewGuid() }; // создадим новое описание
_productDescription.SaveToProductDescription(productDescription); //сохраним его
var productModelProductDescription = new ProductModelProductDescription { Culture = "en ", ModifiedDate = DateTime.Now, ProductDescriptionID = productDescription.ProductDescriptionID, ProductModelID = productModel.ProductModelID, rowguid = Guid.NewGuid() };
productModel.ProductModelProductDescription.Add(productModelProductDescription);
_productModelRepository.SaveToProductModel(productModel);
return RedirectToAction("Index");
}
public void AddToProductDescriptions(ProductDescription productDescription)
{
base.AddObject("ProductDescriptions", productDescription);
}
public static ProductDescription CreateProductDescription(int productDescriptionID, string description, global::System.Guid rowguid, global::System.DateTime modifiedDate)
{
ProductDescription productDescription = new ProductDescription();
productDescription.ProductDescriptionID = productDescriptionID;
productDescription.Description = description;
productDescription.rowguid = rowguid;
productDescription.ModifiedDate = modifiedDate;
return productDescription;
}
partial void UpdateProductDescription(ProductDescription instance);
public void PersistProductTest() {
Version vers01 = new Version(0, 1);
PluginStore target = new PluginStore();
#region persist a product without plugins to the db
{
string prodName = RandomName();
int oldCount = target.Products.Count();
ProductDescription product = new ProductDescription(prodName, vers01);
target.Persist(product);
int newCount = target.Products.Count();
Assert.AreEqual(oldCount + 1, newCount);
}
#endregion
#region persist a product with the same name and version as an existant product
{
string prodName = RandomName();
int oldCount = target.Products.Count();
ProductDescription product = new ProductDescription(prodName, vers01);
target.Persist(product);
int newCount = target.Products.Count();
Assert.AreEqual(oldCount + 1, newCount);
// write a product with same name and version
oldCount = target.Products.Count();
product = new ProductDescription(prodName, vers01);
target.Persist(product);
newCount = target.Products.Count();
// make sure that the old entry was updated
Assert.AreEqual(oldCount, newCount);
// write a product with same name and different version
oldCount = target.Products.Count();
product = new ProductDescription(prodName, new Version(0, 2));
target.Persist(product);
newCount = target.Products.Count();
// make sure that a new entry was created
Assert.AreEqual(oldCount + 1, newCount);
}
#endregion
#region try to persist a product referencing an non-existant plugin and check the expected exception
{
// try to persist a product referencing a non-existant plugin
string prodName = RandomName();
string pluginName = RandomName();
var plugin = new PluginDescription(pluginName, vers01);
var product = new ProductDescription(prodName, vers01, Enumerable.Repeat(plugin, 1));
try {
target.Persist(product);
Assert.Fail("persist should fail with ArgumentException");
}
catch (ArgumentException) {
// this is expected
Assert.IsTrue(true, "expected exception");
}
}
#endregion
#region persist a product with a single plugin reference
{
string prodName = RandomName();
string pluginName = RandomName();
var plugin = new PluginDescription(pluginName, vers01);
var product = new ProductDescription(prodName, vers01, Enumerable.Repeat(plugin, 1));
// persist the plugin first
int oldCount = target.Products.Count();
target.Persist(plugin, enc.GetBytes("Zipped " + plugin.Name));
target.Persist(product);
int newCount = target.Products.Count();
// make sure the store went through
Assert.AreEqual(oldCount + 1, newCount);
// retrieve the product and check if the plugin list was stored/retrieved correctly
var dbProd = target.Products.Where(p => p.Name == prodName).Single();
Assert.AreEqual(dbProd.Plugins.Count(), 1);
Assert.AreEqual(dbProd.Plugins.First().Name, pluginName);
}
#endregion
#region update the plugin list of an existing product
{
string prodName = RandomName();
string plugin1Name = RandomName();
var plugin1 = new PluginDescription(plugin1Name, vers01);
var product = new ProductDescription(prodName, vers01, Enumerable.Repeat(plugin1, 1));
// persist the plugin first
int oldCount = target.Products.Count();
target.Persist(plugin1, enc.GetBytes("Zipped " + plugin1.Name));
target.Persist(product);
int newCount = target.Products.Count();
// make sure the store went through
Assert.AreEqual(oldCount + 1, newCount);
var plugin2Name = RandomName();
var plugin2 = new PluginDescription(plugin2Name, vers01);
target.Persist(plugin2, enc.GetBytes("Zipped " + plugin2.Name));
product = new ProductDescription(prodName, vers01, new PluginDescription[] { plugin1, plugin2 });
oldCount = target.Products.Count();
target.Persist(product);
newCount = target.Products.Count();
// make sure that a new entry was not created
Assert.AreEqual(oldCount, newCount);
// check the plugin list of the product
var dbProduct = target.Products.Where(p => p.Name == prodName).Single();
Assert.AreEqual(dbProduct.Plugins.Count(), 2);
}
#endregion
#region insert a product which references the same plugin twice and check if the correct exception is thrown
{
string prodName = RandomName();
string plugin1Name = RandomName();
var plugin1 = new PluginDescription(plugin1Name, vers01);
var product = new ProductDescription(prodName, vers01, Enumerable.Repeat(plugin1, 2));
// persist the plugin first
target.Persist(plugin1, enc.GetBytes("Zipped " + plugin1.Name));
try {
target.Persist(product);
Assert.Fail("Expected ArgumentException");
}
catch (ArgumentException) {
Assert.IsTrue(true, "Expected exception was thrown.");
}
}
#endregion
}
partial void DeleteProductDescription(ProductDescription instance);
// POST api/awbuildversion
public void Post(ProductDescription value)
{
adventureWorks_BC.ProductDescriptionAdd(value);
}
public void ToXmlStringTest()
{
var description = new ProductDescription(
arbitraryElements: new XElement[] { XElement.Parse("<ArbitraryXml1><Whoa>There</Whoa></ArbitraryXml1>"), XElement.Parse("<ArbitraryXml2><Whoa>There</Whoa></ArbitraryXml2>") },
features: new Dictionary<String, String>() { {"Feature1", "Feature 1 & Bold"}, {"Feature2", "Feature 2"} },
summary: @"This is a summary it can contain HTML markup.
To tell the translation service to ignore some
text, <b>wrap</b> it in a
[do-not-translate]
do not translate
[/do-not-translate]
tag");
String xml = @"
<Description>
<ArbitraryXml1><Whoa>There</Whoa></ArbitraryXml1>
<ArbitraryXml2><Whoa>There</Whoa></ArbitraryXml2>
<Summary>
<![CDATA[
This is a summary it can contain HTML markup.
To tell the translation service to ignore some
text, <b>wrap</b> it in a
[do-not-translate]
do not translate
[/do-not-translate]
tag
]]>
</Summary>
<Features>
<Feature1>Feature 1 & Bold</Feature1>
<Feature2>Feature 2</Feature2>
</Features>
</Description>
";
Assert.AreEqual(Regex.Replace(xml, @"\s", ""), Regex.Replace(description.ToXmlString(), @"\s", ""));
}
public void InsertProductPerformanceTest() {
int nProducts = 50;
int avgProductPlugins = 30;
var store = new PluginStore();
Version vers01 = new Version(0, 1);
Stopwatch stopWatch = new Stopwatch();
Random r = new Random();
var plugins = store.Plugins.ToList();
stopWatch.Start();
// create products
for (int i = 0; i < nProducts; i++) {
string name = RandomName();
List<PluginDescription> prodPlugins = new List<PluginDescription>();
for (int j = 0; j < avgProductPlugins; j++) {
var selectedPlugin = plugins[r.Next(0, plugins.Count)];
if (!prodPlugins.Contains(selectedPlugin)) prodPlugins.Add(selectedPlugin);
}
var prod = new ProductDescription(name, vers01, prodPlugins);
store.Persist(prod);
}
stopWatch.Stop();
Assert.Inconclusive("Created " + nProducts + " products in " + stopWatch.ElapsedMilliseconds +
" ms (" + (double)stopWatch.ElapsedMilliseconds / nProducts + " ms / product )");
}
