private async Task SetCommerceEntityDetails(CommerceEntity commerceEntity, ImportEntityArgument importEntityArgument, CommercePipelineExecutionContext context)
{
if (!importEntityArgument.IsNew)
{
if (importEntityArgument.ImportHandler is IEntityMapper mapper)
{
mapper.Map();
}
else
{
mapper = await _commerceCommander.Pipeline <IResolveEntityMapperPipeline>()
.Run(new ResolveEntityMapperArgument(importEntityArgument, commerceEntity), context)
.ConfigureAwait(false);
if (mapper == null)
{
await context.CommerceContext.AddMessage(context.GetPolicy <KnownResultCodes>().Warning, "EntityMapperMissing", null, $"Entity mapper instance for entityType={importEntityArgument.SourceEntityDetail.EntityType} not resolved.");
}
else
{
mapper.Map();
}
}
}
}
public virtual async Task <CommerceEntity> Process(
CommerceContext commerceContext,
SourceEntityDetail sourceEntityDetail)
{
CommerceEntity result = null;
using (CommandActivity.Start(commerceContext, this))
{
var importEntityArgument = new ImportEntityArgument(sourceEntityDetail);
// Create/Update entity, entity components, manage versions and workflow.
await PerformTransaction(commerceContext, async() => result = await Pipeline <IImportEntityPipeline>().Run(importEntityArgument, commerceContext.PipelineContextOptions));
if (result != null)
{
// Manage association of sellable item with catalog and categories.
await PerformTransaction(commerceContext, async() => await Pipeline <IAssociateParentsPipeline>().Run(importEntityArgument, commerceContext.PipelineContextOptions));
// Manage localization values for sellable item
var importLocalizeContentArgument =
new ImportLocalizeContentArgument(result, importEntityArgument);
await PerformTransaction(commerceContext, async() => await Pipeline <IImportLocalizeContentPipeline>().Run(
importLocalizeContentArgument, commerceContext.PipelineContextOptions));
}
}
return(await Task.FromResult(result));
}
public static IEntityImportHandler GetImportHandler(this Mappings mappings, ImportEntityArgument importEntityArgument, CommerceCommander commerceCommander, CommercePipelineExecutionContext context)
{
var handlerType = mappings
.EntityMappings
.FirstOrDefault(x => x.Key.Equals(importEntityArgument.SourceEntityDetail.EntityType, StringComparison.OrdinalIgnoreCase));
if (handlerType != null)
{
var t = Type.GetType(handlerType.ImportHandlerTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, importEntityArgument.SourceEntityDetail.SerializedEntity,
commerceCommander, context) is
IEntityImportHandler handler)
{
return(handler);
}
}
}
return(null);
}
protected override async Task ImportVariantsInventory(CommerceEntity commerceEntity, ImportEntityArgument importEntityArgument, CommercePipelineExecutionContext context)
{
var sellableItemInventory = importEntityArgument.ImportHandler.GetSourceEntity() as SellableItemInventory;
if (sellableItemInventory == null)
{
return;
}
var inventorySetName = sellableItemInventory.InventorySetName;
if (!string.IsNullOrEmpty(inventorySetName))
{
var inventorySetId = await GetInventorySetName(context, inventorySetName)
.ConfigureAwait(false);
if (!string.IsNullOrEmpty(inventorySetId))
{
var inventoryDetail = sellableItemInventory
.InventoryDetail;
await ImportInventoryInformation(context, commerceEntity, inventorySetId, sellableItemInventory.VariantId, inventoryDetail).ConfigureAwait(false);
}
}
}
private async Task SetCommerceEntityComponents(CommerceEntity commerceEntity, ImportEntityArgument importEntityArgument, CommercePipelineExecutionContext context)
{
if (importEntityArgument.SourceEntityDetail.Components != null && importEntityArgument.SourceEntityDetail.Components.Any())
{
foreach (var componentName in importEntityArgument.SourceEntityDetail.Components)
{
var mapper = await _commerceCommander.Pipeline <IResolveComponentMapperPipeline>()
.Run(new ResolveComponentMapperArgument(importEntityArgument, commerceEntity, componentName), context)
.ConfigureAwait(false);
if (mapper == null)
{
await context.CommerceContext.AddMessage(context.GetPolicy <KnownResultCodes>().Warning, "EntityComponentMapperMissing", null, $"Entity component mapper instance for entityType={importEntityArgument.SourceEntityDetail.EntityType} and component={componentName} not resolved.");
}
else
{
var component = mapper.Execute();
component.SetComponentMetadataPolicy(componentName);
}
}
}
}
public static IComponentMapper GetEntityComponentMapper(this Mappings mappings, CommerceEntity targetEntity, ImportEntityArgument importEntityArgument, string componentMappingKey, CommerceCommander commerceCommander, CommercePipelineExecutionContext context)
{
var mapperType = mappings
.EntityComponentMappings
.FirstOrDefault(x => x.Key.Equals(componentMappingKey, StringComparison.OrdinalIgnoreCase));
if (mapperType != null)
{
var t = Type.GetType(mapperType.FullTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, importEntityArgument.SourceEntity, targetEntity, commerceCommander, context) is
IComponentMapper mapper)
{
return(mapper);
}
}
}
return(null);
}
public static IEntityLocalizationMapper GetEntityLocalizationMapper(this Mappings mappings, ILanguageEntity languageEntity, ImportEntityArgument importEntityArgument, CommerceCommander commerceCommander, CommercePipelineExecutionContext context)
{
var mapperType = mappings
.EntityMappings
.FirstOrDefault(x => x.Key.Equals(importEntityArgument.SourceEntityDetail.EntityType, StringComparison.OrdinalIgnoreCase));
if (mapperType != null)
{
var t = Type.GetType(mapperType.ImportHandlerTypeName ?? mapperType.FullTypeName ?? mapperType.LocalizationFullTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, languageEntity.GetEntity(), commerceCommander, context) is
IEntityLocalizationMapper mapper)
{
return(mapper);
}
}
}
return(null);
}
public static IRelationshipMapper GetRelationshipMapper(this Mappings mappings, ImportEntityArgument importEntityArgument, string relationshipName, CommerceCommander commerceCommander, CommercePipelineExecutionContext context)
{
var mapperType = mappings
.RelationshipMappings
.FirstOrDefault(x => x.Key.Equals(relationshipName, StringComparison.OrdinalIgnoreCase));
if (mapperType != null)
{
var t = Type.GetType(mapperType.FullTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, commerceCommander,
context) is IRelationshipMapper mapper)
{
return(mapper);
}
}
}
return(null);
}
public static IComponentMapper GetItemVariationComponentMapper(this Mappings mappings, CommerceEntity targetEntity, Component parentComponent, ImportEntityArgument importEntityArgument, object sourceComponent, CommerceCommander commerceCommander, CommercePipelineExecutionContext context)
{
var mapperType = mappings
.ItemVariationMappings
.FirstOrDefault();
if (mapperType != null)
{
var t = Type.GetType(mapperType.FullTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, importEntityArgument.SourceEntity, sourceComponent, targetEntity, parentComponent,
commerceCommander, context) is IComponentMapper mapper)
{
return(mapper);
}
}
}
return(null);
}
private async Task ImportVariants(CommerceEntity commerceEntity, ImportEntityArgument importEntityArgument, CommercePipelineExecutionContext context)
{
var orphanVariants = new List <ItemVariationComponent>();
ItemVariationsComponent itemVariationsComponent = null;
var sourceEntityHasVariants = importEntityArgument.ImportHandler.HasVariants();
if (!sourceEntityHasVariants &&
commerceEntity.HasComponent <ItemVariationsComponent>())
{
itemVariationsComponent = commerceEntity.GetComponent <ItemVariationsComponent>();
if (itemVariationsComponent.Variations != null &&
itemVariationsComponent.Variations.Any())
{
orphanVariants = itemVariationsComponent.Variations;
}
}
if (sourceEntityHasVariants)
{
itemVariationsComponent =
commerceEntity.GetComponent <ItemVariationsComponent>();
var variants = importEntityArgument.ImportHandler.GetVariants();
foreach (var variant in variants)
{
var itemVariantMapper = await _commerceCommander.Pipeline <IResolveComponentMapperPipeline>()
.Run(
new ResolveComponentMapperArgument(importEntityArgument, commerceEntity,
itemVariationsComponent, variant, string.Empty), context).ConfigureAwait(false);
if (itemVariantMapper == null)
{
await context.CommerceContext.AddMessage(context.GetPolicy <KnownResultCodes>().Warning, "ItemVariationMapperMissing", null, $"Item variation mapper instance for variantId={variant.Id} not resolved.");
continue;
}
var action = itemVariantMapper.GetComponentAction();
Component itemVariationComponent = itemVariantMapper.Execute(action);
if (action != ComponentAction.Remove &&
importEntityArgument.SourceEntityDetail.VariantComponents != null &&
importEntityArgument.SourceEntityDetail.VariantComponents.Any())
{
foreach (var variantComponentName in importEntityArgument.SourceEntityDetail.VariantComponents)
{
var itemVariantChildComponentMapper = await _commerceCommander
.Pipeline <IResolveComponentMapperPipeline>().Run(new
ResolveComponentMapperArgument(importEntityArgument, commerceEntity,
itemVariationComponent, variant, variantComponentName), context)
.ConfigureAwait(false);
if (itemVariantChildComponentMapper != null)
{
var childComponent = itemVariantChildComponentMapper.Execute();
childComponent.SetComponentMetadataPolicy(variantComponentName);
}
else
{
await context.CommerceContext.AddMessage(context.GetPolicy <KnownResultCodes>().Warning, "ComponentChildComponentMapperMissing", null, $"Component's child component mapper instance for entityType={importEntityArgument.SourceEntityDetail.EntityType} and key={variantComponentName} not resolved.");
}
}
}
}
orphanVariants = (from n in itemVariationsComponent.Variations
join o in variants on n.Id equals o.Id into p
where !p.Any()
select n).ToList();
}
if (itemVariationsComponent != null &&
orphanVariants != null &&
orphanVariants.Any())
{
foreach (var orphanVariant in orphanVariants)
{
if (importEntityArgument.CatalogImportPolicy.DeleteOrphanVariant)
{
itemVariationsComponent.ChildComponents.Remove(orphanVariant);
}
else
{
orphanVariant.Disabled = true;
}
}
}
}
protected override async Task ImportVariantsInventory(CommerceEntity commerceEntity, ImportEntityArgument importEntityArgument, CommercePipelineExecutionContext context)
{
var sourceEntityHasVariants = importEntityArgument.ImportHandler.HasVariants();
if (sourceEntityHasVariants)
{
var inventorySetName = importEntityArgument.ImportHandler
.GetPropertyValueFromSource <InventorySetNameAttribute, string>();
if (!string.IsNullOrEmpty(inventorySetName))
{
var inventorySetId = await GetInventorySetName(context, inventorySetName)
.ConfigureAwait(false);
if (!string.IsNullOrEmpty(inventorySetId))
{
var variants = importEntityArgument.ImportHandler.GetVariants();
foreach (var variant in variants)
{
var inventoryDetail = variant.GetType()
.GetPropertyValueWithAttribute <InventoryDetailAttribute, InventoryDetail>(variant);
await ImportInventoryInformation(context, commerceEntity, inventorySetId,
variant.Id, inventoryDetail).ConfigureAwait(false);
}
}
}
}
}
