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));
}
protected override async Task ImportFileContent(SourceEntityDetail sourceEntityDetail, FileInfo fileInfo)
{
var content = File.ReadAllText(fileInfo.FullName);
if (!string.IsNullOrEmpty(content))
{
var sourceEntities = JsonConvert.DeserializeObject <IList <T> >(content);
if (sourceEntities != null && sourceEntities.Any())
{
foreach (var sourceEntity in sourceEntities)
{
sourceEntityDetail.SerializedEntity = JsonConvert.SerializeObject(sourceEntity);
var command = await ImportContent(sourceEntityDetail)
.ConfigureAwait(false);
var sourceEntityModel = GetSourceEntityModel(sourceEntity, sourceEntityDetail);
if (sourceEntityModel != null)
{
command.Models.Add(sourceEntityModel);
}
var task = this.Log(command);
Task.WaitAll(task);
}
}
}
}
protected override async Task <MinionRunResultsModel> Execute()
{
var catalogImportPolicy = MinionContext.GetPolicy <CatalogImportPolicy>();
if (catalogImportPolicy.Mappings?.EntityMappings != null &&
catalogImportPolicy.Mappings.EntityMappings.Any())
{
if (catalogImportPolicy.IgnoreIndexUpdates)
{
string[] policyKeys =
{
"IgnoreIndexDeletedSitecoreItem",
"IgnoreIndexUpdatedSitecoreItem",
"IgnoreAddEntityToIndexList"
};
MinionContext.AddPolicyKeys(policyKeys);
}
bool success = true;
foreach (var entityMapping in catalogImportPolicy.Mappings.EntityMappings)
{
if (!string.IsNullOrEmpty(entityMapping.Key) &&
!string.IsNullOrEmpty(entityMapping.BulkImporterTypeName))
{
var sourceEntityDetail = new SourceEntityDetail()
{
EntityType = entityMapping.Key,
Components = entityMapping.Components ?? new List <string>(),
VariantComponents = catalogImportPolicy.VariantComponents ?? new List <string>()
};
var t = Type.GetType(entityMapping.BulkImporterTypeName);
if (t != null)
{
if (Activator.CreateInstance(t, _serviceProvider, MinionContext) is IEntityBulkImporter
instance)
{
var result = await instance.Import(sourceEntityDetail).ConfigureAwait(false);
success = result && !success;
}
}
}
}
}
return(new MinionRunResultsModel());
}
protected virtual SourceEntityModel GetSourceEntityModel <T>(T sourceEntity, SourceEntityDetail sourceEntityDetail)
where T : IEntity
{
var entity = sourceEntity as IEntity;
if (entity == null)
{
return(null);
}
return(new SourceEntityModel()
{
Id = entity.Id,
EntityType = sourceEntityDetail.EntityType
});
}
protected virtual async Task <ImportEntityCommand> ImportContent(SourceEntityDetail sourceEntityDetail)
{
using (var newCommerceContext = new CommerceContext(CommerceContext.Logger, CommerceContext.TelemetryClient,
CommerceContext.LocalizableMessagePipeline)
{
GlobalEnvironment = CommerceContext.GlobalEnvironment,
Environment = CommerceContext.Environment,
Headers = CommerceContext.Headers
})
{
string[] policyKeys =
{
"IgnoreCaching"
};
newCommerceContext.AddPolicyKeys(policyKeys);
var command = ServiceProvider.GetService <ImportEntityCommand>();
await command.Process(newCommerceContext, sourceEntityDetail)
.ConfigureAwait(false);
return(command);
}
}
public override async Task <bool> Import(SourceEntityDetail sourceEntityDetail)
{
var fileImportPolicy = CommerceContext.GetPolicy <FileImportPolicy>();
DirectoryInfo directoryInfo = string.IsNullOrEmpty(fileImportPolicy.RootFolder) ? GetDefaultDirectory() : GetDirectory(Path.GetFullPath(fileImportPolicy.RootFolder));
if (directoryInfo != null)
{
var setting = fileImportPolicy.ImportFileSettings.FirstOrDefault(x =>
x.Key.Equals(sourceEntityDetail.EntityType, StringComparison.OrdinalIgnoreCase));
if (setting != null)
{
var files = GetFiles(directoryInfo, setting.FileNamePattern);
foreach (var fileInfo in files)
{
await ImportFileContent(sourceEntityDetail, fileInfo);
}
}
}
return(true);
}
public abstract Task <bool> Import(SourceEntityDetail sourceEntityDetail);
public ImportEntityArgument(SourceEntityDetail sourceEntityDetail)
{
SourceEntityDetail = sourceEntityDetail;
}
protected abstract Task ImportFileContent(SourceEntityDetail sourceEntityDetail, FileInfo fileInfo);
