private void SetOptions(ProductImportDataTransferObject dataTransferObject, Product product)
{
List <string> optionsToAdd =
dataTransferObject.Options.Where(
s => !product.Options.Select(option => option.Name).Contains(s, StringComparer.OrdinalIgnoreCase))
.ToList();
List <ProductOption> optionsToRemove =
product.Options.Where(option => !dataTransferObject.Options.Contains(option.Name)).ToList();
foreach (string option in optionsToAdd)
{
ProductOption existingOption =
_session.QueryOver <ProductOption>()
.Where(productOption => productOption.Name.IsInsensitiveLike(option, MatchMode.Exact))
.Take(1).SingleOrDefault();
if (existingOption == null)
{
existingOption = new ProductOption
{
Name = option,
};
_session.Transact(session => session.Save(existingOption));
}
product.Options.Add(existingOption);
existingOption.Products.Add(product);
}
foreach (ProductOption option in optionsToRemove)
{
product.Options.Remove(option);
option.Products.Remove(product);
}
}
public IEnumerable <string> GetErrors(ProductImportDataTransferObject product)
{
var errors = new List <string>();
try
{
foreach (var item in product.Images)
{
Uri testUri;
var result = Uri.TryCreate(item, UriKind.Absolute, out testUri) &&
(testUri.Scheme == Uri.UriSchemeHttps || testUri.Scheme == Uri.UriSchemeHttp);
if (!result)
{
errors.Add(string.Format(
"{0} is not valid Url.",
item));
}
}
}
catch (Exception)
{
errors.Add("Some of Image Urls are not in correct format.");
}
return(errors);
}
private static void GetBasicData(Dictionary <string, List <string> > parseErrors, ExcelWorksheet worksheet, int rowId,
ProductImportDataTransferObject product, string handle)
{
if (worksheet.GetValue <string>(rowId, 2).HasValue())
{
product.Name = worksheet.GetValue <string>(rowId, 2);
}
else
{
parseErrors[handle].Add("Product Name is required.");
}
product.Description = worksheet.GetValue <string>(rowId, 3);
product.SEOTitle = worksheet.GetValue <string>(rowId, 4);
product.SEODescription = worksheet.GetValue <string>(rowId, 5);
product.SEOKeywords = worksheet.GetValue <string>(rowId, 6);
product.Abstract = worksheet.GetValue <string>(rowId, 7);
product.Brand = worksheet.GetValue <string>(rowId, 8);
if (worksheet.GetValue <string>(rowId, 32).HasValue())
{
if (!worksheet.GetValue <string>(rowId, 32).IsValidDateTime())
{
parseErrors[handle].Add("Publish Date is not a valid date.");
}
else
{
product.PublishDate = worksheet.GetValue <DateTime>(rowId, 32);
}
}
}
public void ImportProductsService_ImportProduct_ShouldSetProductPrimaryProperties()
{
var product = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
Name = "Test Product",
Abstract = "Test Abstract",
Description = "Test Description",
SEODescription = "Test SEO Description",
SEOKeywords = "Test, Thought",
SEOTitle = "Test SEO Title"
};
ProductContainer container = new ProductContainer().PersistTo(Session);
A.CallTo(() => _uniquePageService.GetUniquePage <ProductContainer>()).Returns(container);
MediaCategory category = new MediaCategory().PersistTo(Session);
A.CallTo(() => _documentService.GetDocumentByUrl <MediaCategory>("product-galleries")).Returns(category);
Product result = _importProductsService.ImportProduct(product);
result.UrlSegment.ShouldBeEquivalentTo("test-url");
result.Name.ShouldBeEquivalentTo("Test Product");
result.ProductAbstract.ShouldBeEquivalentTo("Test Abstract");
result.BodyContent.ShouldBeEquivalentTo("Test Description");
result.MetaDescription.ShouldBeEquivalentTo("Test SEO Description");
result.MetaKeywords.ShouldBeEquivalentTo("Test, Thought");
result.MetaTitle.ShouldBeEquivalentTo("Test SEO Title");
}
private static void GetCategories(Dictionary <string, List <string> > parseErrors, ExcelWorksheet worksheet, int rowId,
ProductImportDataTransferObject product, string handle)
{
//Categories
try
{
var value = worksheet.GetValue <string>(rowId, 9);
if (!String.IsNullOrWhiteSpace(value))
{
var Cats = value.Split(';');
foreach (var item in Cats)
{
if (!String.IsNullOrWhiteSpace(item))
{
if (!product.Categories.Any(x => x == item))
{
product.Categories.Add(item);
}
else
{
parseErrors[handle].Add(
"Product Categories field value contains duplicate values.");
break;
}
}
}
}
}
catch (Exception)
{
parseErrors[handle].Add(
"Product Categories field value contains illegal characters / not in correct format.");
}
}
public void ImportProductsService_ImportProducts_ShouldSetCategoriesIfTheyExist()
{
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
Categories = new List <string> {
"test-category"
}
};
var category = new Category {
Id = 1, Name = "Test Category"
};
A.CallTo(() => _documentService.GetDocument <Category>(1)).Returns(category);
var product = new Product {
Name = "Test Product"
};
A.CallTo(() => _documentService.GetDocumentByUrl <Product>(productDTO.UrlSegment)).Returns(product);
Product importProduct = _importProductsService.ImportProduct(productDTO);
importProduct.Categories.Should().HaveCount(1);
}
public void ImportProductVariantsService_ImportVariants_ShouldSetProductVariantTaxRate()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
SKU = "123",
TaxRate = 1
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List <ProductVariantImportDataTransferObject>()
{
productVariantDTO
}
};
var product = new Product {
Name = "Test Product"
};
var taxRate = new TaxRate()
{
Id = 1, Name = "GLOBAL"
};
A.CallTo(() => _taxRateManager.Get(productVariantDTO.TaxRate.Value)).Returns(taxRate);
var result = _importProductVariantsService.ImportVariants(productDTO, product);
result.First().TaxRate.Name.ShouldBeEquivalentTo("GLOBAL");
}
public void ImportProductVariantsService_ImportVariants_ShouldCallImportVariantPriceBreaksOfImportProductVariantPriceBreaksService()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
SKU = "123",
PriceBreaks = new Dictionary <int, decimal>()
{
{ 10, 299 }
}
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List <ProductVariantImportDataTransferObject>()
{
productVariantDTO
}
};
var product = new Product();
var productVariant = new ProductVariant()
{
Name = "Test Product Variant"
};
_importProductVariantsService.ImportVariants(productDTO, product);
A.CallTo(() => _importProductVariantPriceBreaksService.ImportVariantPriceBreaks(productVariantDTO, productVariant)).MustHaveHappened();
}
private static void GetUrlHistory(Dictionary <string, List <string> > parseErrors, ExcelWorksheet worksheet, int rowId,
ProductImportDataTransferObject product, string handle)
{
//Url History
try
{
var value = worksheet.GetValue <string>(rowId, 31);
if (!String.IsNullOrWhiteSpace(value))
{
var urlHistory = value.Split(',');
foreach (var item in urlHistory)
{
if (!String.IsNullOrWhiteSpace(item))
{
product.UrlHistory.Add(item);
}
}
}
}
catch (Exception)
{
parseErrors[handle].Add(
"Product Url History field value contains illegal characters / not in correct format.");
}
}
public void ImportProductsService_ImportProduct_ShouldCallGetGetDocumentByUrlOfDocumentService()
{
var product = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
};
_importProductsService.ImportProduct(product);
A.CallTo(() => _documentService.GetDocumentByUrl <Product>(product.UrlSegment)).MustHaveHappened();
}
public void ImportProductsService_ImportProducts_ShouldSetTheBrandToOneWithTheCorrectNameIfItDoesNotExist()
{
var product = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
Brand = "Test Brand"
};
Product importProduct = _importProductsService.ImportProduct(product);
importProduct.BrandPage.Name.Should().Be("Test Brand");
}
public IEnumerable <ProductSpecificationValue> ImportSpecifications(
ProductImportDataTransferObject dataTransferObject, Product product)
{
List <KeyValuePair <string, string> > specificationsToAdd =
dataTransferObject.Specifications.Where(
s =>
!product.SpecificationValues.Select(value => value.SpecificationName)
.Contains(s.Key, StringComparer.InvariantCultureIgnoreCase)).ToList();
List <ProductSpecificationValue> specificationsToRemove =
product.SpecificationValues.Where(
value =>
!dataTransferObject.Specifications.Keys.Contains(value.SpecificationName,
StringComparer.InvariantCultureIgnoreCase))
.ToList();
List <ProductSpecificationValue> specificationsToUpdate =
product.SpecificationValues.Where(value => !specificationsToRemove.Contains(value)).ToList();
foreach (var item in specificationsToAdd)
{
ProductSpecificationAttribute attribute =
_session.QueryOver <ProductSpecificationAttribute>()
.Where(
specificationAttribute =>
specificationAttribute.Name.IsInsensitiveLike(item.Key, MatchMode.Exact))
.Take(1)
.SingleOrDefault();
if (attribute == null)
{
attribute = new ProductSpecificationAttribute {
Name = item.Key
};
_session.Transact(session => session.Save(attribute));
}
SetValue(product, attribute, item.Value);
}
foreach (ProductSpecificationValue value in specificationsToRemove)
{
RemoveValue(product, value);
}
foreach (ProductSpecificationValue value in specificationsToUpdate)
{
ProductSpecificationAttribute attribute =
value.ProductSpecificationAttributeOption.ProductSpecificationAttribute;
RemoveValue(product, value);
SetValue(product, attribute, dataTransferObject.Specifications[value.SpecificationName]);
}
return(dataTransferObject.Specifications.Any() ? product.SpecificationValues : null);
}
public void ImportProductsService_ImportProduct_ShouldTryToLoadTheCategoryFromTheDocumentService()
{
var product = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
Categories = new List <string> {
"test-category"
}
};
_importProductsService.ImportProduct(product);
A.CallTo(() => _documentService.GetDocumentByUrl <Category>("test-category")).MustHaveHappened();
}
public IEnumerable <string> GetErrors(ProductImportDataTransferObject product)
{
var value = Selector(product);
if (!String.IsNullOrWhiteSpace(value))
{
if (value.Length > Length)
{
yield return
(string.Format(
"{0} is too long - max length is {1} characters and your value is {2} characters in length.",
DisplayName, Length, value.Length));
}
}
}
private static void GetImages(ExcelWorksheet worksheet, int rowId, ProductImportDataTransferObject product)
{
//Images
if (worksheet.GetValue <string>(rowId, 27).HasValue())
{
product.Images.Add(worksheet.GetValue <string>(rowId, 27));
}
if (worksheet.GetValue <string>(rowId, 28).HasValue())
{
product.Images.Add(worksheet.GetValue <string>(rowId, 28));
}
if (worksheet.GetValue <string>(rowId, 29).HasValue())
{
product.Images.Add(worksheet.GetValue <string>(rowId, 29));
}
}
public void ImportProductsService_ImportProducts_ShouldSetProductBrandIfItAlreadyExists()
{
var product = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
Brand = "Test Brand"
};
var brand = new Brand {
Name = "Test BrandPage"
};
Product importProduct = _importProductsService.ImportProduct(product);
importProduct.BrandPage.Should().Be(brand);
}
public void ImportSpecificationsService_ImportSpecifications_ShouldCallGetSpecificationAttributeByNameOfProductOptionManager()
{
var productDTO = new ProductImportDataTransferObject()
{
UrlSegment = "test-url",
Specifications = new Dictionary <string, string>()
{
{ "Storage", "16GB" }
}
};
var product = new Product();
_importSpecificationsService.ImportSpecifications(productDTO, product);
Session.Query <ProductSpecificationAttribute>().First().Options.First().Name.Should().Be("16GB");
}
public void ImportProductVariantsService_ImportVariants_ShouldCallGetProductVariantBySKUOfProductVariantService()
{
var productVariant = new ProductVariantImportDataTransferObject
{
SKU = "123"
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List <ProductVariantImportDataTransferObject>()
{
productVariant
}
};
var product = new Product();
_importProductVariantsService.ImportVariants(productDTO, product);
}
private void SetBrand(ProductImportDataTransferObject dataTransferObject, Product product)
{
//Brand
if (!String.IsNullOrWhiteSpace(dataTransferObject.Brand))
{
string dtoBrand = dataTransferObject.Brand.Trim();
Brand brand =
_session.QueryOver <Brand>()
.Where(b => b.Name.IsInsensitiveLike(dtoBrand, MatchMode.Exact))
.Take(1)
.SingleOrDefault();
if (brand == null)
{
brand = _getNewBrandPage.Get(dtoBrand);
_session.Transact(session => session.Save(brand));
}
product.BrandPage = brand;
}
}
private static void GetSpecifications(Dictionary <string, List <string> > parseErrors, ExcelWorksheet worksheet, int rowId, string handle,
ProductImportDataTransferObject product)
{
//Specifications
var specificationsValue = worksheet.GetValue <string>(rowId, 10);
if (!String.IsNullOrWhiteSpace(specificationsValue))
{
try
{
if (!String.IsNullOrWhiteSpace(specificationsValue))
{
if (!specificationsValue.Contains(":"))
{
parseErrors[handle].Add(
"Product Specifications field value contains illegal characters / not in correct format. Names and Values (Item) must be split with :, and items must be split by ;");
}
var specs = specificationsValue.Split(';');
foreach (var item in specs)
{
if (!String.IsNullOrWhiteSpace(item))
{
string[] specificationValue = item.Split(':');
if (!String.IsNullOrWhiteSpace(specificationValue[0]) &&
!String.IsNullOrWhiteSpace(specificationValue[1]) &&
!product.Specifications.ContainsKey(
specificationValue[0]))
{
product.Specifications.Add(specificationValue[0],
specificationValue[1]);
}
}
}
}
}
catch (Exception)
{
parseErrors[handle].Add(
"Product Specifications field value contains illegal characters / not in correct format. Names and Values (Item) must be split with :, and items must be split by ;");
}
}
}
public void ImportProductService_ImportProducts_ShouldCallImportUrlHistoryOfImportProductUrlHistoryService()
{
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
UrlHistory = new List <string> {
"test-url-old"
}
};
var product = new Product {
Name = "Test Product"
};
A.CallTo(() => _documentService.GetDocumentByUrl <Product>(productDTO.UrlSegment)).Returns(product);
_importProductsService.ImportProduct(productDTO);
A.CallTo(() => _importProductUrlHistoryService.ImportUrlHistory(productDTO, product)).MustHaveHappened();
}
public void ImportSpecificationsService_ImportSpecifications_ShouldAddANewSpecificationAttributeIfItDoesntExist()
{
var productDTO = new ProductImportDataTransferObject()
{
UrlSegment = "test-url",
Specifications = new Dictionary <string, string>()
{
{ "Storage", "16GB" }
}
};
var product = new Product()
{
Name = "Test Product"
};
_importSpecificationsService.ImportSpecifications(productDTO, product);
Session.Query <ProductSpecificationAttribute>().First().Options.Should().HaveCount(1);
}
public void ImportSpecificationsService_ImportSpecifications_ShouldSetSpecifications()
{
var productDTO = new ProductImportDataTransferObject()
{
UrlSegment = "test-url",
Specifications = new Dictionary <string, string>()
{
{ "Storage", "16GB" }
}
};
var product = new Product()
{
Name = "Test Product"
};
_importSpecificationsService.ImportSpecifications(productDTO, product);
product.SpecificationValues.Should().HaveCount(1);
}
public IEnumerable <string> GetErrors(ProductImportDataTransferObject product)
{
var errors = new List <string>();
var mrCmsProduct = _productService.GetByUrl(product.UrlSegment);
foreach (var pv in product.ProductVariants)
{
var mrCmsVariant = _productVariantService.GetProductVariantBySKU(pv.SKU);
if (mrCmsVariant != null)
{
if (mrCmsProduct == null || (mrCmsVariant.Product.Id != mrCmsProduct.Id))
{
errors.Add(string.Format("Product Variant with SKU {0} already exists on product with Url Segment {1}", pv.SKU, mrCmsVariant.Product.UrlSegment));
}
}
}
return(errors);
}
public void SetCategories(ProductImportDataTransferObject dataTransferObject, Product product)
{
//Categories
List <string> categoriesToAdd =
dataTransferObject.Categories.Where(
s =>
!product.Categories.Select(category => category.UrlSegment)
.Contains(s, StringComparer.OrdinalIgnoreCase)).ToList();
List <Category> categoriesToRemove =
product.Categories.Where(
category =>
!dataTransferObject.Categories.Contains(category.UrlSegment, StringComparer.OrdinalIgnoreCase))
.ToList();
foreach (string item in categoriesToAdd)
{
Category category =
_session.QueryOver <Category>()
.Where(c => c.UrlSegment.IsInsensitiveLike(item, MatchMode.Exact))
.Take(1)
.SingleOrDefault();
if (category != null)
{
product.Categories.Add(category);
if (!category.Products.Contains(product))
{
category.Products.Add(product);
}
}
}
foreach (Category category in categoriesToRemove)
{
product.Categories.Remove(category);
if (category.Products.Contains(product))
{
category.Products.Remove(product);
}
}
}
public void ImportProductVariantsService_ImportVariants_ShouldSetProductVariantPrimaryProperties()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
PreviousPrice = 2,
Price = 1,
SKU = "123",
Name = "Test Product Variant",
TrackingPolicy = TrackingPolicy.Track,
Weight = 0,
Barcode = "456",
Stock = 5
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List <ProductVariantImportDataTransferObject>()
{
productVariantDTO
}
};
var product = new Product()
{
Name = "Test Product"
};
var result = _importProductVariantsService.ImportVariants(productDTO, product);
result.First().PreviousPrice.ShouldBeEquivalentTo(2);
result.First().BasePrice.ShouldBeEquivalentTo(1);
result.First().SKU.ShouldBeEquivalentTo("123");
result.First().Name.ShouldBeEquivalentTo("Test Product Variant");
result.First().TrackingPolicy.ShouldBeEquivalentTo(TrackingPolicy.Track);
result.First().Weight.ShouldBeEquivalentTo(0);
result.First().Barcode.ShouldBeEquivalentTo("456");
result.First().StockRemaining.ShouldBeEquivalentTo(5);
}
public void ImportUrlHistory(ProductImportDataTransferObject productDto, Product product)
{
List<string> urlsToAdd =
productDto.UrlHistory.Where(
s =>
!product.Urls.Select(history => history.UrlSegment)
.Contains(s, StringComparer.InvariantCultureIgnoreCase)).ToList();
//List<UrlHistory> urlsToRemove =
// product.Urls.Where(
// history =>
// !productDto.UrlHistory.Contains(history.UrlSegment, StringComparer.InvariantCultureIgnoreCase))
// .ToList();
foreach (string item in urlsToAdd)
{
UrlHistory history =
_session.Query<UrlHistory>().FirstOrDefault(urlHistory => urlHistory.UrlSegment == item);
bool isNew = history == null;
if (isNew)
{
history = new UrlHistory { UrlSegment = item, Webpage = product };
_session.Transact(session => session.Save(history));
}
else
history.Webpage = product;
if (!product.Urls.Contains(history))
product.Urls.Add(history);
_session.Transact(session => session.Update(history));
}
//foreach (UrlHistory history in urlsToRemove)
//{
// product.Urls.Remove(history);
// history.Webpage = null;
// UrlHistory closureHistory = history;
// _session.Transact(session => session.Update(closureHistory));
//}
}
public void ImportProductVariantsService_ImportVariants_ShouldAddVariantsToProduct()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
SKU = "123"
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List <ProductVariantImportDataTransferObject>()
{
productVariantDTO
}
};
var product = new Product()
{
Name = "Test Product"
};
_importProductVariantsService.ImportVariants(productDTO, product);
product.Variants.Should().HaveCount(1);
}
public IEnumerable <string> GetErrors(ProductImportDataTransferObject product)
{
return((from item in product.Categories
where _documentService.GetDocumentByUrl <Category>(item) == null
select string.Format("Category with url: {0} is not present within the system.", item)).ToList());
}
/// <summary>
/// Validate And Import Products With Variants
/// </summary>
/// <param name="spreadsheet"></param>
/// <param name="parseErrors"></param>
/// <returns></returns>
public HashSet <ProductImportDataTransferObject> ValidateAndImportProductsWithVariants(ExcelPackage spreadsheet, ref Dictionary <string, List <string> > parseErrors)
{
var productsToImport = new HashSet <ProductImportDataTransferObject>();
if (!parseErrors.Any())
{
if (spreadsheet != null)
{
if (spreadsheet.Workbook != null)
{
var worksheet = spreadsheet.Workbook.Worksheets.SingleOrDefault(x => x.Name == "Items");
if (worksheet != null)
{
var totalRows = worksheet.Dimension.End.Row;
for (var rowId = 2; rowId <= totalRows; rowId++)
{
if (!worksheet.GetValue <string>(rowId, 1).HasValue() &&
!worksheet.GetValue <string>(rowId, 2).HasValue() &&
!worksheet.GetValue <string>(rowId, 3).HasValue())
{
continue;
}
var product = new ProductImportDataTransferObject();
//Prepare handle name for storing and grouping errors
string url = worksheet.GetValue <string>(rowId, 1),
name = worksheet.GetValue <string>(rowId, 2);
var handle = url.HasValue() ? url : SeoHelper.TidyUrl(name);
if (!productsToImport.Any(x => x.Name == name || x.UrlSegment == url))
{
if (parseErrors.All(x => x.Key != handle))
{
parseErrors.Add(handle, new List <string>());
}
product.UrlSegment = worksheet.GetValue <string>(rowId, 1).HasValue()
? worksheet.GetValue <string>(rowId, 1)
: _urlService.Suggest(null,
new SuggestParams
{
PageName = name,
DocumentType = typeof(Product).FullName
});
//skip duplicate url
if (productsToImport.Any(x => x.UrlSegment == product.UrlSegment))
{
continue;
}
GetBasicData(parseErrors, worksheet, rowId, product, handle);
GetCategories(parseErrors, worksheet, rowId, product, handle);
GetSpecifications(parseErrors, worksheet, rowId, handle, product);
GetImages(worksheet, rowId, product);
GetUrlHistory(parseErrors, worksheet, rowId, product, handle);
productsToImport.Add(product);
}
else
{
product = !string.IsNullOrWhiteSpace(url) ?
productsToImport.SingleOrDefault(x => x.Name == name && x.UrlSegment == url)
: productsToImport.SingleOrDefault(x => x.Name == name);
}
//Variants
if (product != null)
{
var productVariant = GetProductVariant(parseErrors, worksheet, rowId, handle);
if (productVariant != null)
{
//Options
GetProductVariantOptions(worksheet, rowId, productVariant);
//Price Breaks
GetPriceBreaks(parseErrors, worksheet, rowId, handle, productVariant);
product.ProductVariants.Add(productVariant);
}
}
}
}
}
}
//Remove handles with no errors
parseErrors = parseErrors.Where(x => x.Value.Any()).ToDictionary(pair => pair.Key, pair => pair.Value);
}
var i = productsToImport.Where(x => x.ProductVariants.Count == 0).ToList();
return(productsToImport);
}
