public void InsertProduct()
{
_container = EntityContainer.InsertableContainer <Domain.Models.Product> .ContainerConfig();
try
{
using (var scope = _container.BeginLifetimeScope())
{
var insertableProduct = _container.Resolve <EntityService.Interfaces.IInsertable <Domain.Models.Product> >();
var Product = new Domain.Models.Product()
{
BuyCount = 0,
ImageFileAddress = "insert test",
Name = "test test",
ShortDescription = "short test",
Status = true,
TextFileAddress = "test text"
};
insertableProduct.Insert(Product);
}
}
catch (Exception error)
{
Assert.Fail(error.Message);
}
}
public async Task GetProductAsync_ProductExists_ReturnsProduct()
{
// Arrange
var productId = Guid.NewGuid();
var product = new Domain.Models.Product
{
Id = productId,
Name = "Product Name",
Description = "Product Description",
Price = 100,
DeliveryPrice = 2
};
_mockProductRepository
.Setup(m => m.GetProductAsync(It.IsAny <Guid>()))
.ReturnsAsync(product);
// Act
var result = await _sut.GetProductAsync(productId);
// Assert
Assert.AreEqual(product.Name, result.Name);
Assert.AreEqual(product.Description, result.Description);
Assert.AreEqual(product.Price, result.Price);
Assert.AreEqual(product.DeliveryPrice, result.DeliveryPrice);
}
public async Task <AddProductOutputDto> AddProductAsync(AddProductInputDto aParams)
{
var output = new AddProductOutputDto();
try
{
var item = new Domain.Models.Product
{
Name = aParams.Name,
Price = aParams.Price,
DeliveryPrice = aParams.DeliveryPrice,
Description = aParams.Description,
ProductOptions = Mapper.Map <List <Domain.Models.ProductOption> >(aParams.ProductOptions)
};
Domain.Models.Product product = await UnitOfWork.ProductRepository.AddProductAsync(item);
await UnitOfWork.SaveChanges();
output = Mapper.Map <AddProductOutputDto>(product);
}
catch (Exception e)
{
output.ResultErrors.Messages.Add(e.Message);
}
return(output);
}
public async Task DeleteProductAsync_IsSuccessful_ReturnsTrue()
{
// Arrange
var productId = Guid.NewGuid();
var product = new Domain.Models.Product()
{
Id = productId,
Name = "Product Name",
Description = "Product Description",
Price = 100,
DeliveryPrice = 2
};
_mockProductRepository
.Setup(m => m.GetProductAsync(It.IsAny <Guid>()))
.ReturnsAsync(product);
_mockProductRepository
.Setup(m => m.DeleteProductAsync(It.IsAny <Guid>()))
.ReturnsAsync(true);
// Act
var result = await _sut.DeleteProductAsync(productId);
// Assert
Assert.That(result, Is.True);
}
public async Task CreateProductAsync_IsSuccessful_ReturnsTrue()
{
// Arrange
var productId = Guid.NewGuid();
var dto = new CreateProduct()
{
Name = "Product Name",
Description = "Product Description",
Price = 100,
DeliveryPrice = 2
};
var product = new Domain.Models.Product()
{
Id = productId,
Name = "Product Name",
Description = "Product Description",
Price = 100,
DeliveryPrice = 2
};
_mockProductRepository
.Setup(m => m.CreateProductAsync(It.IsAny <Domain.Models.Product>()))
.ReturnsAsync(product);
// Act
var result = await _sut.CreateProductAsync(dto);
// Assert
Assert.AreEqual(result.Id, productId);
Assert.AreEqual(result.Name, "Product Name");
Assert.AreEqual(result.Description, "Product Description");
Assert.AreEqual(result.Price, 100);
Assert.AreEqual(result.DeliveryPrice, 2);
}
public async Task <ProductResponse> UpdateAsync(int id, Domain.Models.Product product)
{
var existingProduct = await _productRepository.FindByIdAsync(id);
if (existingProduct == null)
{
return(new ProductResponse("Product not found."));
}
var existingItem = await _itemRepository.FindByIdAsync(product.ItemId);
if (existingItem == null)
{
return(new ProductResponse("Invalid item."));
}
existingProduct.Name = product.Name;
existingProduct.UnitOfMeasurement = product.UnitOfMeasurement;
existingProduct.QuantityInPackage = product.QuantityInPackage;
existingProduct.ItemId = product.ItemId;
try
{
_productRepository.Update(existingProduct);
await _unitOfWork.CompleteAsync();
return(new ProductResponse(existingProduct));
}
catch (Exception ex)
{
// Do some logging stuff
return(new ProductResponse($"An error occurred when updating the product: {ex.Message}"));
}
}
public async Task <ProductResponse> SaveAsync(Domain.Models.Product product)
{
try
{
/*
* Notice here we have to check if the item ID is valid before adding the product, to avoid errors.
* You can create a method into the ItemService class to return the item and inject the service here if you prefer, but
* it doesn't matter given the API scope.
*/
var existingItem = await _itemRepository.FindByIdAsync(product.ItemId);
if (existingItem == null)
{
return(new ProductResponse("Invalid item."));
}
await _productRepository.AddAsync(product);
await _unitOfWork.CompleteAsync();
return(new ProductResponse(product));
}
catch (Exception ex)
{
// Do some logging stuff
return(new ProductResponse($"An error occurred when saving the product: {ex.Message}"));
}
}
public async Task <UpdateProductOutputDto> UpdateProductAsync(UpdateProductInputDto aParams)
{
var output = new UpdateProductOutputDto();
try
{
var item = new Domain.Models.Product
{
Id = aParams.Id,
Name = aParams.Name,
Price = aParams.Price,
DeliveryPrice = aParams.DeliveryPrice,
Description = aParams.Description,
ProductOptions = Mapper.Map <List <Domain.Models.ProductOption> >(aParams.ProductOptions)
};
await UnitOfWork.ProductRepository.UpdateProductAsync(item);
await UnitOfWork.SaveChanges();
var updatedRecord = await UnitOfWork.ProductRepository.GetProductAsync(aParams.Id);
output = Mapper.Map <UpdateProductOutputDto>(updatedRecord);
}
catch (Exception e)
{
output.ResultErrors.Messages.Add(e.Message);
}
return(output);
}
public async Task <IActionResult> Post([FromBody] Domain.Models.Product product)
{
await _productService.AddAsync(product);
return(Created($"/api/product/{product.Id}", new Domain.Models.Product {
Id = product.Id
}));
}
public int Add(Domain.Models.Product newItem)
{
int newId = _productsList[_productsList.Count - 1].Id + 1;
newItem.Id = newId;
_productsList.Add(newItem);
return(newId);
}
public void Setup()
{
var context = new Domain.DataAccess.MahourContext();
_gallery = context.GalleryTable.FirstOrDefault();
_project = context.ProjectTable.FirstOrDefault();
_product = context.ProductTable.FirstOrDefault();
if (_project == null)
{
var Project = new Domain.Models.Project()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Name = "test",
ShortDescription = "test",
State = "0",
Status = true,
TextFileAddress = "test",
TimeToFinish = 150
};
context.ProjectTable.Add(Project);
context.SaveChanges();
_project = Project;
}
if (_product == null)
{
var Product = new Domain.Models.Product()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Name = "test",
ShortDescription = "test",
Status = true,
TextFileAddress = "test"
};
context.ProductTable.Add(Product);
context.SaveChanges();
_product = Product;
}
if (_gallery == null)
{
var Gallery = new Domain.Models.Gallery()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Description = "some test",
Project = _project,
Product = _product
};
context.GalleryTable.Add(Gallery);
context.SaveChanges();
_gallery = Gallery;
}
}
private void Process(Domain.Models.Product sku)
{
using (var db = new YintaiHZhouContext()) {
var p = db.Products.FirstOrDefault(t => t.Id == sku.Id);
p.IsHasImage = true;
p.UpdatedDate = DateTime.Now;
p.UpdatedUser = SystemDefine.SystemUser;
db.SaveChanges();
}
}
public void Setup()
{
var context = new Domain.DataAccess.MahourContext();
_platform = context.PlatformTable.FirstOrDefault();
_project = context.ProjectTable.FirstOrDefault();
_product = context.ProductTable.FirstOrDefault();
if (_project == null)
{
var Project = new Domain.Models.Project()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Name = "test",
ShortDescription = "test",
State = "0",
Status = true,
TextFileAddress = "test",
TimeToFinish = 150
};
context.ProjectTable.Add(Project);
context.SaveChanges();
_project = Project;
}
if (_product == null)
{
var Product = new Domain.Models.Product()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Name = "test",
ShortDescription = "test",
Status = true,
TextFileAddress = "test"
};
context.ProductTable.Add(Product);
context.SaveChanges();
_product = Product;
}
if (_platform == null)
{
var Platform = new Domain.Models.Platform()
{
ID = DateTime.Now.Ticks.ToString(),
Name = "test",
IconFileAddress = "test Icon"
};
context.PlatformTable.Add(Platform);
_platform = Platform;
}
}
public Domain.Models.Product Update(Domain.Models.Product newItem)
{
var existing = _productsList.SingleOrDefault(a => a.Id == newItem.Id);
if (existing != null)
{
existing.Name = newItem.Name;
}
return(existing);
}
public async Task <int> Handle(CreateProductCommand command, CancellationToken cancellationToken)
{
var product = new Domain.Models.Product();
product.Barcode = command.Barcode;
product.Name = command.Name;
product.BuyingPrice = command.BuyingPrice;
product.Rate = command.Rate;
product.Description = command.Description;
var result = _context.Products.Add(product);
return(result);
}
public async Task GetAllProductOptionsAsync_ReturnsAllOptionsOnProduct()
{
// Arrange
var productId = Guid.NewGuid();
var options = new List <ProductOption>
{
new ProductOption
{
ProductId = productId,
Name = "Product Option Name 1",
Description = "Product Option Description 1"
},
new ProductOption
{
ProductId = productId,
Name = "Product Option Name 2",
Description = "Product Option Description 2"
}
};
var product = new Domain.Models.Product()
{
Id = productId,
Name = "Product Name",
Description = "Product Description",
Price = 100,
DeliveryPrice = 2
};
_mockProductRepository
.Setup(m => m.GetProductAsync(It.IsAny <Guid>()))
.ReturnsAsync(product);
_mockProductRepository
.Setup(m => m.GetAllProductOptionsAsync(It.IsAny <Guid>()))
.ReturnsAsync(options);
// Act
var results = await _sut.GetAllProductOptionsAsync(productId);
// Assert
Assert.That(results.Count, Is.EqualTo(2));
Assert.AreEqual(options[0].Name, results[0].Name);
Assert.AreEqual(options[0].Description, results[0].Description);
Assert.AreEqual(options[1].Name, results[1].Name);
Assert.AreEqual(options[1].Description, results[1].Description);
}
public async Task <long> Handle(CreateProductCommand request, CancellationToken cancellationToken)
{
var product = new Domain.Models.Product
{
UserId = request.UserId,
DatePurchased = request.DatePurchased,
Description = request.Description.Trim(),
Price = request.Price,
Paid = request.Paid,
CategoryId = request.CategoryId
};
_context.Product.Add(product);
await _context.SaveChangesAsync(cancellationToken);
return(product.Id);
}
public async Task <CreateProductCommandDto> Handle(CreateProductCommand request, CancellationToken cancellationToken)
{
var input = request.data.attributes;
var product = new Domain.Models.Product
{
name = input.name,
price = input.price
};
//_context.products.Add(product);
//await _context.SaveChangesAsync(cancellationToken);
return(new CreateProductCommandDto
{
Message = "Success add product data",
Success = true,
Data = product
});
}
public void Setup()
{
var context = new Domain.DataAccess.MahourContext();
if (_product == null)
{
var Product = new Domain.Models.Product()
{
ID = DateTime.Now.Ticks.ToString(),
ImageFileAddress = "test",
Name = "test",
ShortDescription = "test",
Status = true,
TextFileAddress = "test"
};
context.ProductTable.Add(Product);
context.SaveChanges();
_product = Product;
}
}
public async Task <ProductDto> AddProductAsync(AddProductDto model)
{
Domain.Models.Product product = new Domain.Models.Product()
{
Name = model.Name,
Description = model.Description,
Price = model.Price,
Category = model.Category
};
await _productRepository.AddAsync(product);
return(new ProductDto()
{
Id = product.Id,
Name = product.Name,
Description = product.Description,
Price = product.Price,
Category = product.Category
});
}
public Domain.Models.Product GetProduct(int productId)
{
Domain.Models.Product result = null;
try
{
_logger.LogInformation("BEGIN GetProduct");
result = LactafarmaService.GetProduct(productId);
_logger.LogInformation("END GetProduct");
}
catch (Exception ex)
{
_logger.LogError($"Exception on JsonResult called GetProduct(productId={productId}) with message {ex.Message}");
}
finally
{
if (result == null)
{
_logger.LogWarning("No results for current request!!!");
}
}
return(result);
}
public async Task <Response> Do(Request request)
{
var product = new Domain.Models.Product
{
Name = request.Name,
Description = request.Description,
Value = request.Value
};
_context.Products.Add(product);
await _context.SaveChangesAsync();
return(new Response
{
Id = product.Id,
Name = product.Name,
Description = product.Description,
Value = product.Value
});
}
public void RemoveProduct()
{
_container = EntityContainer.RemoveableContainer.ContainerConfig <EntityService.Entities.Product.ModifiableProduct>(_product.ID);
try
{
using (var scope = _container.BeginLifetimeScope())
{
var removeableProduct = _container.Resolve <EntityService.Interfaces.IRemoveable>();
removeableProduct.Remove();
}
}
catch (Exception error)
{
Assert.Fail(error.Message);
}
finally
{
_product = new Domain.DataAccess.MahourContext().ProductTable.FirstOrDefault();
}
}
public async Task CreateProductOptionAsync_IsSuccessful_ReturnsTrue()
{
// Arrange
var productId = Guid.NewGuid();
var dto = new CreateProductOption()
{
Name = "Product Option Name",
Description = "Product Option Description"
};
var product = new Domain.Models.Product
{
Name = "Product Name 1",
Description = "Product Description 1",
Price = 100,
DeliveryPrice = 2
};
var option = new ProductOption
{
Name = "Product Option Name 1",
Description = "Product Option Description 1",
};
_mockProductRepository
.Setup(m => m.GetProductAsync(It.IsAny <Guid>()))
.ReturnsAsync(product);
_mockProductRepository
.Setup(m => m.CreateProductOptionAsync(It.IsAny <ProductOption>()))
.ReturnsAsync(option);
// Act
var result = await _sut.CreateProductOptionAsync(productId, dto);
// Assert
Assert.AreEqual(option.Name, result.Name);
Assert.AreEqual(option.Description, result.Description);
}
public Domain.Models.Product Sync(ProductDto channelProduct)
{
/**
* 首先同步相关信息
* 1. 同步品牌
* 2. 同步分类
* 3. 同步专柜及门店
* 4. 同步商品基本信息
*/
/**
* 检查并同步专柜, 同步专柜信息时同时会同步门店信息，在此无需再同步门店
*/
var section = _sectionSyncProcessor.Sync(channelProduct.SectionId, channelProduct.StoreNo);
if (section == null)
{
Log.ErrorFormat("同步商品对应专柜失败:productId:[{0}]，sectionId:[1],stroeNo:[{2}]", channelProduct.ProductId, channelProduct.SectionId, channelProduct.StoreNo);
return(null);
}
/**
* 检查并同步品牌,目前集团的商品只有品牌名称，所以同步商品不成功，只是提供警告
*/
var brand = _brandSyncProcessor.SyncBrand(channelProduct.BrandId, channelProduct.BrandName);
if (brand == null)
{
var channelMap = _channelMapper.GetMapByChannelValue(channelProduct.BrandName, ChannelMapType.Brand);
if (channelMap == null)
{
//品牌没有的，按所属专柜在查找，如果没有的，如果有则关联此品牌；如果没有，则依据专柜创建品牌并关联
using (var db = new YintaiHZhouContext())
{
brand =
db.Brands.Where(
b =>
b.Name.Trim().ToUpper() == section.Name.Trim().ToUpper() ||
b.EnglishName.Trim().ToUpper() == section.Name.Trim().ToUpper() && b.Status == 1)
.OrderByDescending(x => x.Id)
.FirstOrDefault();
if (brand == null)
{
/**
* 品牌映射关系不存在，
*
* 1. 创建新品牌
* 2. 保存映射关系
*/
var newBrand = new Brand()
{
//ChannelBrandId = brandSource.BrandId,
Name = section.Name,
EnglishName = string.Empty,
Logo = string.Empty,
Status = 1,
Description = string.Empty,
Group = string.Empty,
WebSite = string.Empty,
CreatedDate = DateTime.Now,
CreatedUser = SystemDefine.SystemUser,
UpdatedDate = DateTime.Now,
UpdatedUser = SystemDefine.SystemUser,
};
// 添加品牌并保持
brand = db.Brands.Add(newBrand);
db.SaveChanges();
}
else
{
if (brand.Status != 1)
{
brand.Status = 1;
brand.UpdatedDate = DateTime.Now;
db.SaveChanges();
}
}
// 添加映射关系
var newChannelMap = new ChannelMap()
{
LocalId = brand.Id,
ChannnelValue = section.Name.Trim().ToUpper(),
MapType = ChannelMapType.Brand
};
_channelMapper.CreateMap(newChannelMap);
}
}
else
{
using (var db = new YintaiHZhouContext())
{
brand = db.Brands.FirstOrDefault(x => x.Id == channelMap.LocalId);
}
}
Log.WarnFormat("同步商品对应品牌失败:ProductId:[{0}],brandId:[{1}],brandName:[{2}]", channelProduct.ProductId, channelProduct.BrandId, channelProduct.BrandName);
}
using (var db = new YintaiHZhouContext())
{
if (!db.IMS_SectionBrand.Any(x => x.BrandId == brand.Id && x.SectionId == section.Id))
{
var sb = new IMS_SectionBrand()
{
BrandId = brand.Id,
SectionId = section.Id
};
db.IMS_SectionBrand.Add(sb);
db.SaveChanges();
}
}
/**
* 检查并同步分类,目前集团分类信息为空，所以同步商品不成功，只是提供警告
*/
var category = _categorySyncProcessor.Sync(channelProduct.CategoryId4, channelProduct.Category4);
if (category == null)
{
//如果分类为空，设置一个默认值
Log.WarnFormat("同步商品对应分类失败:[{0}],categoryId:[{1}],category:[{2}]", channelProduct.ProductId, channelProduct.CategoryId4, channelProduct.Category4);
}
var tagId = FetchTagId(channelProduct);
int catid;
if (!string.IsNullOrEmpty(channelProduct.CategoryId4))
{
int.TryParse(channelProduct.CategoryId4, out catid);
}
else
{
catid = 0;
}
using (var db = new YintaiHZhouContext())
{
/**
* 同步商品基本信息,
* 说明 productId为商品唯一标识
* productCode为商品的款编号
* 商品款号加上品牌id唯一标识
*/
var mapKey = string.Format("{1}-{0}", channelProduct.ProductCode, brand.Id);
var productCodeMap = _channelMapper.GetMapByChannelValue(mapKey, ChannelMapType.ProductCode);
if (productCodeMap == null)
{
var newProduct = new Domain.Models.Product()
{
ProductType = 1,
Brand_Id = brand.Id,
Name = string.IsNullOrEmpty(channelProduct.ProductName) ? string.Format("{0}-{1}", brand.Name, channelProduct.ProductCode) : channelProduct.ProductName,
UnitPrice = channelProduct.LabelPrice,
Store_Id = section.StoreId ?? 0,
Price = channelProduct.CurrentPrice,
Description = string.Empty,
SkuCode = channelProduct.ProductCode,
Is4Sale = false, //商品属性同步完成了，设置为true
RecommendedReason = string.Empty,
RecommendUser = DEFAULT_OWNER_ID,
SortOrder = 0,
Status = 1,
Tag_Id = tagId,
BarCode = string.Empty,
Favorable = "1",
UpdatedDate = DateTime.Now,
UpdatedUser = DEFAULT_OWNER_ID,
CreatedDate = DateTime.Now,
CreatedUser = DEFAULT_OWNER_ID,
};
newProduct = db.Products.Add(newProduct);
db.SaveChanges();
// 保存映射关系
_channelMapper.CreateMap(new ChannelMap()
{
LocalId = newProduct.Id,
ChannnelValue = mapKey,
MapType = ChannelMapType.ProductCode
});
// 保存本地商品Id和渠道的对应的关系，用于如更新图片等功能的使用
_channelMapper.CreateMap(new ChannelMap()
{
LocalId = newProduct.Id,
ChannnelValue = channelProduct.ProductId,
MapType = ChannelMapType.ProductId
});
if (catid > 0)
{
CreateProductMap(channelProduct, newProduct.Id, catid);
}
return(newProduct);
}
var proudctExt = db.Products.FirstOrDefault(p => p.Id == productCodeMap.LocalId);
if (proudctExt == null)
{
Log.ErrorFormat("商品productId:[{0}],productcode:[{1}],存在映射关系，商品数据不存在", channelProduct.ProductId, channelProduct.ProductCode);
return(null);
}
var productMap = _channelMapper.GetMapByChannelValue(channelProduct.ProductId, ChannelMapType.ProductId);
if (productMap == null)
{
// 保存本地商品Id和渠道的对应的关系，用于如更新图片等功能的使用
_channelMapper.CreateMap(new ChannelMap()
{
LocalId = proudctExt.Id,
ChannnelValue = channelProduct.ProductId,
MapType = ChannelMapType.ProductId
});
}
//proudctExt.BarCode = string.Empty;
proudctExt.Store_Id = section.StoreId ?? 0;
proudctExt.Brand_Id = brand == null ? 0 : brand.Id;
proudctExt.Tag_Id = tagId;
proudctExt.SkuCode = channelProduct.ProductCode;
proudctExt.Name = string.IsNullOrEmpty(channelProduct.ProductName) ? string.Format("{0}-{1}", brand.Name, channelProduct.ProductCode) : channelProduct.ProductName;
proudctExt.UnitPrice = channelProduct.LabelPrice;
proudctExt.Price = channelProduct.CurrentPrice;
//proudctExt.Description = string.Empty;
//proudctExt.RecommendedReason = string.Empty;
proudctExt.UpdatedDate = DateTime.Now;
proudctExt.UpdatedUser = DEFAULT_OWNER_ID;
if (catid > 0 && !db.ProductMaps.Any(x => x.Channel == SystemDefine.IntimeChannel && x.ProductId == proudctExt.Id))
{
CreateProductMap(channelProduct, proudctExt.Id, catid);
}
db.SaveChanges();
return(proudctExt);
}
}
public async Task <int> AddAsync(Domain.Models.Product product)
{
_unit.ProductRepository.Add(product);
return(await _unit.CommitChangesAsync());
}
public async Task <int> UpdateAsync(Domain.Models.Product product)
{
_unit.ProductRepository.Update(product.Id, product);
return(await _unit.CommitChangesAsync());
}
public async Task AddAsync(Domain.Models.Product product)
{
await _context.Products.AddAsync(product);
}
public void Update(Domain.Models.Product product)
{
_context.Products.Update(product);
}
public void Remove(Domain.Models.Product product)
{
_context.Products.Remove(product);
}
