public PipelineExecutionResult Execute(Category subject)
{
var idToDelete = subject.Name;
logging.Log <DeleteCategoryFromKaching>("Deleting tag: " + subject.Name + " in Ka-ching");
var config = KachingConfiguration.Get();
var url = config.TagsIntegrationURL;
if (url.StartsWith("https://", StringComparison.Ordinal))
{
var idsToDelete = new List <string>();
idsToDelete.Add(idToDelete);
var result = Synchronizer.Delete(idsToDelete, url);
if (result == PipelineExecutionResult.Error)
{
return(result);
}
}
var folders = new CategoryConverter(logging).GetFolders();
var foldersUrl = config.FoldersIntegrationURL;
if (!foldersUrl.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
return(Synchronizer.Post(folders, foldersUrl));
}
private void PostTags(List <KachingTag> tags)
{
var config = KachingConfiguration.Get();
var url = config.TagsIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return;
}
Synchronizer.Post(tags, url);
}
private void UpdateButtonState()
{
var config = KachingConfiguration.Get();
var urls = new List <string> {
config.ProductsIntegrationURL, config.TagsIntegrationURL, config.FoldersIntegrationURL
};
var canImport = urls.All(s => s != null && s.StartsWith("https:", StringComparison.Ordinal));
StartCategoryImportButton.Enabled = canImport;
StartProductImportButton.Enabled = canImport;
}
public CategoryExportService(
ReferenceConverter referenceConverter,
IContentLoader contentLoader,
IContentVersionRepository contentVersionRepository,
L10nStringFactory l10nStringFactory)
{
_configuration = KachingConfiguration.Instance;
_referenceConverter = referenceConverter;
_contentLoader = contentLoader;
_contentVersionRepository = contentVersionRepository;
_l10nStringFactory = l10nStringFactory;
}
public PipelineExecutionResult UpdateFolders(Category subject)
{
var config = KachingConfiguration.Get();
var url = config.FoldersIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
var folders = new CategoryConverter(logging).GetFolders();
return(Synchronizer.Post(folders, url));
}
public ProductExportService(
IAssociationRepository associationRepository,
GroupDefinitionRepository <AssociationGroupDefinition> associationGroupRepository,
ReferenceConverter referenceConverter,
IContentLoader contentLoader,
ProductFactory productFactory,
IPublishedStateAssessor publishedStateAssessor)
{
_associationRepository = associationRepository;
_associationGroupRepository = associationGroupRepository;
_referenceConverter = referenceConverter;
_configuration = KachingConfiguration.Instance;
_contentLoader = contentLoader;
_productFactory = productFactory;
_publishedStateAssessor = publishedStateAssessor;
}
private PipelineExecutionResult PostTag(KachingTag tag)
{
var config = KachingConfiguration.Get();
var url = config.TagsIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
var tags = new List <KachingTag>();
tags.Add(tag);
return(Synchronizer.Post(tags, url));
}
protected void Page_Load(object sender, EventArgs e)
{
UpdateButtonState();
GetPriceGroupData();
GetCultureCodeData();
if (!Page.IsPostBack)
{
BindPriceGroupList();
BindCultureCodeList();
var config = KachingConfiguration.Get();
ProductsImportURL.Text = config.ProductsIntegrationURL;
TagsImportURL.Text = config.TagsIntegrationURL;
FoldersImportURL.Text = config.FoldersIntegrationURL;
}
}
public PipelineExecutionResult Execute(Product subject)
{
var config = KachingConfiguration.Get();
var url = config.ProductsIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
// In case a product is initially being created, it will not yet have a
// category configured. In this case delay the synchronization slightly
// in order to let the database save the product<->category relationship.
Func <PipelineExecutionResult> synchronize = () =>
{
var converter = new ProductConverter(logging);
var product = converter.ConvertProduct(subject);
KachingProduct[] products = new KachingProduct[1];
products[0] = product;
var metadata = converter.GetMetadata();
return(Synchronizer.Post(new ProductsRequest(products, metadata), url));
};
if (subject.GetCategories().Count == 0)
{
Task.Delay(2000).ContinueWith((task) =>
{
synchronize();
});
return(PipelineExecutionResult.Success);
}
return(synchronize());
}
private int ImportProducts(IEnumerable <Product> products)
{
var config = KachingConfiguration.Get();
var url = config.ProductsIntegrationURL;
if (!url.StartsWith("https://", StringComparison.Ordinal))
{
return(0);
}
var converter = new ProductConverter(logger);
List <KachingProduct> kachingProducts = new List <KachingProduct>();
foreach (var product in products)
{
kachingProducts.Add(converter.ConvertProduct(product));
}
var metadata = converter.GetMetadata();
Synchronizer.Post(new ProductsRequest(kachingProducts.ToArray(), metadata), url);
return(kachingProducts.Count);
}
public Product BuildKaChingProduct(
ProductContent product,
ICollection <string> tags,
KachingConfiguration configuration,
string skipVariantCode)
{
var kachingProduct = new Product();
kachingProduct.Id = product.Code.SanitizeKey();
kachingProduct.Barcode = GetPropertyStringValue(product, configuration.SystemMappings.BarcodeMetaField);
kachingProduct.Name = _l10nStringFactory.GetLocalizedString(product, nameof(product.DisplayName));
kachingProduct.Description = _l10nStringFactory.GetLocalizedString(product, configuration.SystemMappings.DescriptionMetaField);
foreach (var mapping in configuration.AttributeMappings.Cast <AttributeMappingElement>())
{
object value = GetAttributeValue(product, mapping.MetaField);
if (value == null)
{
continue;
}
kachingProduct.Attributes[mapping.AttributeId] = value;
}
/* ---------------------------- */
/* Example of dimension and dimension value construction from the Quicksilver site. */
/* ---------------------------- */
//var dimensions = new List<Dimension>();
//var sizeDimension = new Dimension();
//sizeDimension.Id = "Size";
//sizeDimension.Name = new L10nString("Size");
//sizeDimension.Values = new List<DimensionValue>();
//foreach (var size in product.AvailableSizes)
//{
// var sizeValue = new DimensionValue();
// sizeValue.Id = size.ToLower().Replace(' ', '_');
// sizeValue.Name = new L10nString(size);
// sizeDimension.Values.Add(sizeValue);
//}
//dimensions.Add(sizeDimension);
//var colorDimension = new Dimension();
//colorDimension.Id = "Color";
//colorDimension.Name = new L10nString("Color");
//colorDimension.Values = new List<DimensionValue>();
//foreach (var color in product.AvailableColors)
//{
// var colorValue = new DimensionValue();
// colorValue.Id = color.ToLower().Replace(' ', '_');
// colorValue.Name = new L10nString(color);
// colorDimension.Values.Add(colorValue);
//}
//dimensions.Add(colorDimension);
//kachingProduct.Dimensions = dimensions;
CommerceMedia productImage = product.CommerceMediaCollection.FirstOrDefault();
if (productImage != null)
{
Uri absoluteUrl = GetAbsoluteUrl(productImage.AssetLink);
kachingProduct.ImageUrl = absoluteUrl?.AbsoluteUri;
}
IEnumerable <ContentReference> variantRefs = _relationRepository
.GetChildren <ProductVariation>(product.ContentLink)
.Select(r => r.Child);
ICollection <VariationContent> variants = _contentLoader
.GetItems(variantRefs, LanguageSelector.MasterLanguage())
.OfType <VariationContent>()
.ToArray();
if (variants.Count == 1 &&
configuration.ExportSingleVariantAsProduct)
{
// If the product has only one variant and ExportSingleVariantAsProduct is configured to true,
// then put all variant properties on the product instead.
var variant = variants.First();
kachingProduct.Id = variant.Code.SanitizeKey();
kachingProduct.Barcode = GetPropertyStringValue(variant, configuration.SystemMappings.BarcodeMetaField);
kachingProduct.Name = _l10nStringFactory.GetLocalizedString(variant, nameof(variant.DisplayName));
MarketPrice retailPrice = MarketPriceForCode(variant.Code);
AddProductPricing(kachingProduct, product, retailPrice, configuration.SystemMappings.PriceUnitMetaField);
foreach (var mapping in configuration.AttributeMappings.Cast <AttributeMappingElement>())
{
object value = GetAttributeValue(variant, mapping.MetaField);
if (value == null)
{
continue;
}
kachingProduct.Attributes[mapping.AttributeId] = value;
}
if (kachingProduct.ImageUrl == null)
{
CommerceMedia variantImage = variant.CommerceMediaCollection.FirstOrDefault();
if (variantImage != null)
{
Uri absoluteUrl = GetAbsoluteUrl(variantImage.AssetLink);
kachingProduct.ImageUrl = absoluteUrl?.AbsoluteUri;
}
}
}
else if (variants.Count > 0)
{
var kachingVariants = new List <Variant>(variants.Count);
foreach (var variant in variants)
{
if (skipVariantCode != null &&
skipVariantCode == variant.Code)
{
continue;
}
var kachingVariant = new Variant();
kachingVariant.Id = variant.Code.SanitizeKey();
kachingVariant.Barcode = GetPropertyStringValue(variant, configuration.SystemMappings.BarcodeMetaField);
var variantName = _l10nStringFactory.GetLocalizedString(variant, nameof(variant.DisplayName));
if (!variantName.Equals(kachingProduct.Name))
{
kachingVariant.Name = variantName;
}
if (kachingProduct.UnitPricing == null)
{
kachingVariant.RetailPrice = MarketPriceForCode(variant.Code);
}
foreach (var mapping in configuration.AttributeMappings.Cast <AttributeMappingElement>())
{
object value = GetAttributeValue(variant, mapping.MetaField);
if (value == null)
{
continue;
}
kachingVariant.Attributes[mapping.AttributeId] = value;
}
CommerceMedia variantImage = variant.CommerceMediaCollection.FirstOrDefault();
if (variantImage != null)
{
Uri absoluteUrl = GetAbsoluteUrl(variantImage.AssetLink);
kachingVariant.ImageUrl = absoluteUrl?.AbsoluteUri;
}
if (kachingProduct.ImageUrl == null)
{
kachingProduct.ImageUrl = kachingVariant.ImageUrl;
}
kachingVariants.Add(kachingVariant);
}
kachingProduct.Variants = kachingVariants;
}
/* ---------------------------- */
/* Assign tags to enable category navigation */
/* ---------------------------- */
kachingProduct.Tags = new Dictionary <string, bool>();
foreach (var tag in tags)
{
kachingProduct.Tags[tag] = true;
}
return(kachingProduct);
}
