private void UpdateProduct(Guid productId)
{
Log("UpdateProduct");
// Show product info
try {
_productId = productId;
_productContract =
new ProductServiceClient().ProductGetCompleteById(
productId
);
textBoxProductName.Text = _productContract.Product.ProductName;
stateRefComboProduct.Text = _productContract.Product.StateRcd;
dateTimePickerProduct.Text = _productContract.Product.DateTime.ToLongDateString();
PopulateProductAttribute(_productContract.ProductAttribute);
PopulateProductIdentifier(_productContract.ProductIdentifier);
PopulateProductInfo(_productContract.ProductInfo);
PopulateProductImage(_productContract.ProductImage);
PopulateProductDocument(_productContract.ProductDocumentation);
PopulateProductHistory();
} catch (Exception ex) {
Error("UpdateProduct", ex);
}
}
public static void CreateProduct(string name, string code, string price)
{
int priceNumber;
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(nameof(name));
}
if (string.IsNullOrEmpty(code))
{
throw new ArgumentException(nameof(code));
}
if (!int.TryParse(price, out priceNumber))
{
throw new ArgumentException(nameof(priceNumber));
}
var newProduct = new ProductContract()
{
Code = code,
Name = name,
Price = priceNumber,
};
_service.AddProduct(newProduct);
}
private void UpdateProduct(Guid productId)
{
// Show product info
var productServiceClient = new ProductServiceClient();
try {
_productContract =
productServiceClient.ProductGetCompleteById(
productId);
if (productId == Guid.Empty)
{
// todo
// either set this to empty here, or allow comobo / datetime, etc to be null/empty
// note 1.. not doing this now because it causes flicker in the end
//textBoxProductName.Text = string.Empty;
//stateRefComboProduct.Text = string.Empty;
//dateTimePickerProduct.Text = string.Empty;
}
else
{
textBoxProductName.Text = _productContract.Product.ProductName;
PopulateProductAttribute(_productContract.ProductAttribute);
PopulateProductIdentifier(_productContract.ProductIdentifier);
PopulateProductInfo(_productContract.ProductInfo);
PopulateProductImage(_productContract.ProductImage);
PopulateProductDocument(_productContract.ProductDocumentation);
}
} catch (Exception ex) {
Error(ex);
} finally {
productServiceClient.Close();
}
}
public async Task <bool> AddProductDapper(ProductContract prd)
{
int affectedRows = 0;
string sqlCustomerInsert = @"INSERT INTO [dbo].[Products]
([Title]
,[BusinessName]
,[Cost]
,[Quantity]
,[TotalCost])
VALUES
(@Title
,@BusinessName
,@Cost
,@Quantity
,@TotalCost)";
using (var connection = new SqlConnection(
))
{
affectedRows = await connection.ExecuteAsync(sqlCustomerInsert, new
{
Title = "TestProductDapper",
BusinessName = "TestProductDapper",
Cost = 12,
Quantity = 3,
TotalCost = 36
});
}
return(affectedRows > 0);
}
public CartItemSummary ShowCartItems(string deviceNumber, string cuponCode = "")
{
try
{
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string host = (string)settingsReader.GetValue("WebHostName", typeof(String));
using (var productContract = new ProductContract())
{
var products = productContract.ShowCartItems(deviceNumber, cuponCode);
products.CartItems.ForEach(x =>
{
x.ProductImages.ForEach(y =>
{
y.GalleryImageURL = y.GalleryImageURL.Replace("..", host);
y.ImageURL = y.ImageURL.Replace("..", host);
y.ThumbImageURL = y.ThumbImageURL.Replace("..", host);
});
});
return(products);
}
}
catch
{
throw;
}
}
private void ValidateProduct(ProductContract product)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
if (string.IsNullOrEmpty(product.Name))
{
throw new ArgumentNullException(nameof(product.Name));
}
if (string.IsNullOrEmpty(product.Code))
{
throw new ArgumentNullException(nameof(product.Code));
}
if (product.Attributes == null)
{
throw new ArgumentNullException(nameof(product.Attributes));
}
foreach (var attribute in product.Attributes)
{
ValidateAttribute(attribute);
}
}
public static List <ProductContract> ProductListToContract(IEnumerable <Product> PList)
{
List <ProductContract> PContractList = new List <ProductContract>();
foreach (Product PModel in PList)
{
ProductContract PContract = new ProductContract();
PContract.Class = PModel.Class;
PContract.Color = PModel.Color;
PContract.DaysToManufacture = PModel.DaysToManufacture;
PContract.ListPrice = PModel.ListPrice;
PContract.ModifiedDate = PModel.ModifiedDate;
PContract.Name = PModel.Name;
PContract.ProductID = PModel.ProductID;
PContract.ProductLine = PModel.ProductLine;
PContract.ProductModelID = PModel.ProductModelID;
PContract.ProductNumber = PModel.ProductNumber;
PContract.SafetyStockLevel = PModel.SafetyStockLevel;
PContract.Size = PModel.Size;
PContract.StandardCost = PModel.StandardCost;
PContract.Style = PModel.Style;
PContract.Weight = PModel.Weight;
PContract.LargePhoto = PModel.ProductProductPhoto.First().ProductPhoto.LargePhoto;
PContract.ThumbNailPhoto = PModel.ProductProductPhoto.First().ProductPhoto.ThumbNailPhoto;
PContractList.Add(PContract);
}
return(PContractList);
}
public ProductDetailsSummaryModel GetAllProducts(SearchProductModel search, string deviceNo)
{
try
{
ProductDetailsSummaryModel objProduct = new ProductDetailsSummaryModel();
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string host = (string)settingsReader.GetValue("WebHostName", typeof(String));
using (var productContract = new ProductContract())
{
var products = productContract.GetProducts(search, deviceNo, false);
objProduct.ProductList = products;
objProduct.FilterCategories = productContract.GetFilterCategory(products);
objProduct.FilterBrands = productContract.GetFilterBrand(products);
objProduct.FilterArtists = productContract.GetFilterArtists(products);
objProduct.FilterVendors = productContract.GetFilterVendors(products);
objProduct.ProductList.ForEach(x =>
{
x.ProductImages.ForEach(y =>
{
y.GalleryImageURL = y.GalleryImageURL.Replace("..", host);
y.ImageURL = y.ImageURL.Replace("..", host);
y.ThumbImageURL = y.ThumbImageURL.Replace("..", host);
});
});
if (objProduct.FilterCategories != null)
{
objProduct.FilterCategories.ForEach(x =>
{
x.PictureUrl = x.PictureUrl.Replace("..", host);
});
}
if (objProduct.FilterBrands != null)
{
objProduct.FilterBrands.ForEach(x =>
{
x.PictureURL = x.PictureURL.Replace("..", host);
});
}
if (objProduct.FilterArtists != null)
{
objProduct.FilterArtists.ForEach(x =>
{
x.PictureURL = x.PictureURL.Replace("..", host);
});
}
if (objProduct.FilterVendors != null)
{
objProduct.FilterVendors.ForEach(x =>
{
x.PictureURL = x.PictureURL.Replace("..", host);
});
}
return(objProduct);
}
}
catch
{
throw;
}
}
public ProductDetailsModel GetProductDetails(int productId, CurrencyTypeName currencyTypeName)
{
try
{
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string host = (string)settingsReader.GetValue("WebHostName", typeof(String));
using (var productContract = new ProductContract())
{
var product = productContract.GetProductDetails(productId, currencyTypeName);
if (product != null && product.ProductImages != null && product.ProductImages.Count() > 0)
{
product.ProductImages.ForEach(y =>
{
y.GalleryImageURL = y.GalleryImageURL.Replace("..", host);
y.ImageURL = y.ImageURL.Replace("..", host);
y.ThumbImageURL = y.ThumbImageURL.Replace("..", host);
});
}
return(product);
}
}
catch
{
throw;
}
}
public bool UpdateProduct(ProductContract product)
{
var productContract = _mapper.GetProduct(product);
var state = _productRepository.UpdateProduct(productContract);
return(state);
}
public List <ProductSummaryModel> GetFeaturedProducts(CurrencyTypeName currencyTypeName, string deviceNo)
{
try
{
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string host = (string)settingsReader.GetValue("WebHostName", typeof(String));
var search = new SearchProductModel
{
CurrencyName = currencyTypeName,
};
using (var productContract = new ProductContract())
{
var products = productContract.GetProducts(search, deviceNo, true);
products.ForEach(x =>
{
x.ProductImages.ForEach(y =>
{
y.GalleryImageURL = y.GalleryImageURL.Replace("..", host);
y.ImageURL = y.ImageURL.Replace("..", host);
y.ThumbImageURL = y.ThumbImageURL.Replace("..", host);
});
});
return(products);
}
}
catch
{
throw;
}
}
public async Task <BaseResponse> Execute(ProductContract obj)
{
return(new BaseResponse
{
Message = "Product Added Successfully",
Success = await _prdRepo.DeleteProduct(obj)
});
}
public ActionResult Post([FromBody] ProductContract product)
{
var savedProduct = productRepository.Add(
new Product(product.Name, product.Description, product.Quantity,
new Category(product.Category),
Domain.Unit.Get(product.Unit.ToString())));
return(Created($"api/odata/Products?$filter=id eq ", savedProduct.Id));
}
public async Task <bool> AddProduct(ProductContract prd)
{
ProductContext dbCon = new ProductContext();
//Automapper performance issue will occur in case of 1000+ mapping. Here it should have no performance issue
dbCon.Products.Add(_mapper.Map <Product>(prd));
_noOfRows = await dbCon.SaveChangesAsync(true, _cnclToken);
return(_noOfRows > 0);
}
public JsonResult AddProduct(int merchId, [FromBody] ProductContract productContract)
{
var prod = _productRepository.AddProduct(merchId, productContract);
if (prod == null)
{
return(Json(new object[] { }));
}
return(Json(prod));
}
private async Task HandleTradingDisabled(ProductContract product, string username)
{
if (product.IsTradingDisabled)
{
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Trading disabled for product {product.ProductId}");
var allRfq = await RetrieveAllRfq(product.ProductId, canBePaused : true);
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Found rfqs to pause: {allRfq.Select(x => x.Id).ToJson()}");
foreach (var rfq in allRfq)
{
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Trying to pause rfq: {rfq.Id}");
await _rfqPauseService.AddAsync(rfq.Id,
PauseSource.TradingDisabled,
username);
}
}
else
{
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Trading enabled for product {product.ProductId}");
var allRfq = await RetrieveAllRfq(product.ProductId, canBeResumed : true, canBeStopped : true);
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Found rfqs to resume or stop: {allRfq.Select(x => x.Id).ToJson()}");
foreach (var rfq in allRfq)
{
if (rfq.PauseSummary?.CanBeResumed ?? false)
{
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Trying to resume rfq: {rfq.Id}");
await _rfqPauseService.ResumeAsync(rfq.Id,
PauseCancellationSource.TradingEnabled,
username);
}
else if (rfq.PauseSummary?.CanBeStopped ?? false)
{
_log.WriteInfo(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Trying to stop pending pause for rfq: {rfq.Id}");
await _rfqPauseService.StopPendingAsync(rfq.Id,
PauseCancellationSource.TradingEnabled,
username);
}
else
{
_log.WriteWarning(nameof(ProductChangedProjection), nameof(HandleTradingDisabled),
$"Unexpected state for rfq: {rfq.Id}, {rfq.ToJson()}");
}
}
}
}
public object Add(ProductContract contract)
{
if (contract == null)
{
throw new ProductIsNullException();
}
var product = this.adapter.Convert(contract);
product.Validate();
return(this.productRepository.Add(product).Id);
}
public void MapProductWillReturnCorrectResult(Product product, ContractMapper sut)
{
// Fixture setup
var expectedContract = product.AsSource().OfLikeness <ProductContract>()
.With(d => d.UnitPrice).EqualsWhen((s, d) => s.UnitPrice.AsSource().OfLikeness <MoneyContract>().Equals(d.UnitPrice));
// Exercise system
ProductContract result = sut.Map(product);
// Verify outcome
Assert.True(expectedContract.Equals(result));
// Teardown
}
public void ShouldBeAbleToConvertAProductContractToModel(int id, string name, decimal value)
{
var contract = new ProductContract {
Id = id, Name = name, Value = value
};
var model = this.adapter.Convert(contract);
Assert.IsNotNull(model);
Assert.AreEqual(contract.Id, model.Id);
Assert.AreEqual(contract.Name, model.Name);
Assert.AreEqual(contract.Value, model.Value);
}
public void Save(ProductContract entitiy, int ProductId)
{
ProductQuantity productQuantity = new ProductQuantity();
productQuantity.PId = ProductId;
productQuantity.Quantity = entitiy.Quantity;
productQuantity.Rate = entitiy.Rate;
productQuantity.CreatedBy = 2;
productQuantity.CreatedDate = DateTime.Now;
productQuantity.Status = 10;
this.Add(productQuantity);
}
public void ShouldValidateProductBeforeAdd(string name, decimal value, Type exceptionType)
{
var stub = new ProductContract {
Name = name,
Value = value
};
this.adapterMock.Setup(m => m.Convert(stub)).Returns(new Product(name, value)).Verifiable();
Assert.Throws(exceptionType, () => this.service.Add(stub));
this.adapterMock.Verify(m => m.Convert(stub), Times.Once());
}
public ProductViewModel Map(ProductContract contract)
{
if (contract == null)
{
throw new ArgumentNullException("contract");
}
var vm = new ProductViewModel();
vm.Id = contract.Id;
vm.Name = contract.Name;
vm.UnitPrice = this.Map(contract.UnitPrice);
return vm;
}
public ProductViewModel Map(ProductContract contract)
{
if (contract == null)
{
throw new ArgumentNullException("contract");
}
var vm = new ProductViewModel();
vm.Id = contract.Id;
vm.Name = contract.Name;
vm.UnitPrice = this.Map(contract.UnitPrice);
return(vm);
}
public async Task <bool> DeleteProduct(ProductContract prd)
{
ProductContext dbCon = new ProductContext();
//Automapper performance issue will occur in case of 1000+ mapping. Here it should have no performance issue
Product productToDelete = dbCon.Products.Where(i => i.Title.Equals(_mapper.Map <Product>(prd).Title)).FirstOrDefault();
int noOfRows = 0;
if (productToDelete != null)
{
dbCon.Products.Remove(productToDelete);
noOfRows = await dbCon.SaveChangesAsync(true, _cnclToken);
}
return(noOfRows > 0);
}
public void Edit(object id, ProductContract contract)
{
if (contract == null)
{
throw new ProductIsNullException();
}
var product = this.productRepository.GetById(id);
product.Name = contract.Name;
product.Value = contract.Value;
product.Validate();
this.productRepository.Edit(product);
}
public void AddProduct(ProductContract product)
{
try
{
ValidateProduct(product);
productRepository.Insert(Mapper.Map <ProductContract, Product>(product));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public bool AddToCart(int productId, CurrencyTypeName currencyTypeName, string deviceNumber)
{
try
{
using (var productContract = new ProductContract())
{
var product = productContract.AddToCart(productId, currencyTypeName, deviceNumber);
return(product);
}
}
catch
{
throw;
}
}
public List <ProductBasicModel> GetProductSuggestions()
{
try
{
using (var productContract = new ProductContract())
{
var products = productContract.GetProductSuggestions();
return(products);
}
}
catch
{
throw;
}
}
public void ShouldBeAbleToGetAProductById(object id)
{
var productStub = new Product(id, "name", 20);
var contractStub = new ProductContract();
this.productRepositoryMock.Setup(m => m.GetById(id)).Returns(productStub).Verifiable();
this.adapterMock.Setup(m => m.Convert(productStub)).Returns(contractStub).Verifiable();
var response = this.service.GetById(id);
Assert.AreSame(contractStub, response);
this.productRepositoryMock.Verify(m => m.GetById(id), Times.Once());
this.adapterMock.Verify(m => m.Convert(productStub), Times.Once());
}
public void ShouldBeAbleToEditAProduct(string name, decimal value)
{
var stub = new ProductContract {
Name = name,
Value = value
};
this.productRepositoryMock.Setup(m => m.GetById(1)).Returns(new Product(1, "name", 20)).Verifiable();
this.productRepositoryMock.Setup(m => m.Edit(It.IsAny <Product>())).Verifiable();
this.service.Edit(1, stub);
this.productRepositoryMock.Verify(m => m.GetById(1), Times.Once());
this.productRepositoryMock.Verify(m => m.Edit(It.Is <Product>(p => p.Id.Equals(1) && p.Name.Equals(name) && p.Value.Equals(value))), Times.Once());
}
public bool RemoveFromWishList(int productId, string deviceNumber)
{
try
{
using (var productContract = new ProductContract())
{
var product = productContract.RemoveFromWishList(productId, deviceNumber);
return(product);
}
}
catch
{
throw;
}
}
public ProductContract Map(ProductEditorViewModel productEditorViewModel)
{
if (productEditorViewModel == null)
{
throw new ArgumentNullException("productEditorViewModel");
}
var pc = new ProductContract();
pc.Id = productEditorViewModel.Id;
pc.Name = productEditorViewModel.Name;
pc.UnitPrice = new MoneyContract
{
Amount = decimal.Parse(productEditorViewModel.Price),
CurrencyCode = productEditorViewModel.Currency
};
return pc;
}
private int ProductConverter()
{
var reference = "QWERTY12345";
var expected = new ProductContract{
BasePrice = 123.4M,
Description = "TEST PRODUCT 1",
Name = "TEST PRODUCT 1",
SerialNumber = reference
};
var dao = new ProductDao();
dao.ProcessRequest(new ProductOperationRequest {Action = DataAction.Create,Product = expected });
var result = dao.ProcessRequest(new ProductOperationRequest {Action = DataAction.Read, NamePart = reference});
var actual = result.Products.FirstOrDefault();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.BasePrice,actual.BasePrice);
Assert.AreEqual(expected.Description,actual.Description);
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.SerialNumber, actual.SerialNumber);
return actual.ProductId.GetValueOrDefault();
}
public CartContract AddItemToCart(ProductContract product, CartContract cart)
{
//do database stuff
return cart;
}
public void MapProductContractWillReturnCorrectResult(ProductContract contract, ContractMapper sut)
{
// Fixture setup
var expectedProduct = contract.AsSource().OfLikeness<Product>()
.With(d => d.UnitPrice).EqualsWhen((s, d) => new Money(s.UnitPrice.Amount, s.UnitPrice.CurrencyCode).Equals(d.UnitPrice));
// Exercise system
Product result = sut.Map(contract);
// Verify outcome
Assert.True(expectedProduct.Equals(result));
// Teardown
}
