/// <summary>
/// Run
/// </summary>
/// <param name="arg">arg</param>
/// <param name="context">context</param>
/// <returns>flag if the process was sucessfull</returns>
public override async Task <ImportComposerTemplatePipelineModel> Run(ImportComposerTemplatePipelineModel arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The arg can not be null");
Condition.Requires(arg.Arguments).IsNotNull($"{this.Name}: The import arguments can not be null");
Condition.Requires(arg.InputComposerTemplates).IsNotNull($"{this.Name}: The composer templates can not be null");
if (arg.Arguments.ImportType != ImportType.Merge)
{
return(await Task.FromResult(arg));
}
IList <ComposerTemplate> existingComposerTemplates = _composerTemplateService.GetAllComposerTemplates(context.CommerceContext);
foreach (CustomComposerTemplate composerTemplate in arg.InputComposerTemplates)
{
ComposerTemplate newComposerTemplate = composerTemplate.ToComposerTemplate();
ComposerTemplate existingComposerTemplate = existingComposerTemplates.FirstOrDefault(element => element.Id.Equals(newComposerTemplate.Id));
if (existingComposerTemplate != null)
{
// TODO Merge existing composer template with new one ????
// If we take existing one then version and entity verison increment
// If we take new one, delete existing one first
}
var persistResult = await this._persistEntityCommand.Process(context.CommerceContext, newComposerTemplate);
}
arg.Success = true;
return(await Task.FromResult(arg));
}
/// <summary>
/// Run
/// </summary>
/// <param name="arg">arg</param>
/// <param name="context">context</param>
/// <returns>flag if the process was sucessfull</returns>
public override async Task <ImportComposerTemplatePipelineModel> Run(ImportComposerTemplatePipelineModel arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The arg can not be null");
Condition.Requires(arg.Arguments).IsNotNull($"{this.Name}: The import arguments can not be null");
Condition.Requires(arg.InputComposerTemplates).IsNotNull($"{this.Name}: The composer templates can not be null");
if (arg.Arguments.ImportType != ImportType.Skip)
{
return(await Task.FromResult(arg));
}
IList <ComposerTemplate> existingComposerTemplates = _composerTemplateService.GetAllComposerTemplates(context.CommerceContext);
foreach (CustomComposerTemplate composerTemplate in arg.InputComposerTemplates)
{
ComposerTemplate newComposerTemplate = composerTemplate.ToComposerTemplate();
ComposerTemplate existingComposerTemplate = existingComposerTemplates.FirstOrDefault(element => element.Id.Equals(newComposerTemplate.Id));
if (existingComposerTemplate != null)
{
Log.Information($"SkipComposerTemplatesBlock: Skipping import of {newComposerTemplate.Id}");
continue;
}
var persistResult = await this._persistEntityCommand.Process(context.CommerceContext, newComposerTemplate);
}
arg.Success = true;
return(await Task.FromResult(arg));
}
/// <summary>
/// Run
/// </summary>
/// <param name="arg">arg</param>
/// <param name="context">context</param>
/// <returns>flag if the process was sucessfull</returns>
public override async Task <ImportComposerTemplatePipelineModel> Run(ImportComposerTemplatePipelineModel arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The arg can not be null");
Condition.Requires(arg.Arguments).IsNotNull($"{this.Name}: The import arguments can not be null");
Condition.Requires(arg.InputComposerTemplates).IsNotNull($"{this.Name}: The composer templates can not be null");
if (arg.Arguments.ImportType != ImportType.Override)
{
return(await Task.FromResult(arg));
}
IList <ComposerTemplate> existingComposerTemplates = _composerTemplateService.GetAllComposerTemplates(context.CommerceContext);
foreach (CustomComposerTemplate composerTemplate in arg.InputComposerTemplates)
{
ComposerTemplate newComposerTemplate = composerTemplate.ToComposerTemplate();
ComposerTemplate existingComposerTemplate = existingComposerTemplates.FirstOrDefault(element => element.Id.Equals(newComposerTemplate.Id));
if (existingComposerTemplate != null)
{
// Try to increase version count instead of delete
DeleteEntityArgument result = await _deleteEntityCommand.Process(context.CommerceContext, existingComposerTemplate.Id);
if (!result.Success)
{
Log.Error($"OverrideComposerTemplatesBlock: Deletion of {newComposerTemplate.Id} failed - new Template was not imported");
}
}
var persistResult = await this._persistEntityCommand.Process(context.CommerceContext, newComposerTemplate);
}
arg.Success = true;
return(await Task.FromResult(arg));
}
public override async Task <bool> Run(CreateComposerTemplatesArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The argument can not be null");
//Create the template, add the view and the properties
string itemId = $"Composer-{Guid.NewGuid()}";
var composerTemplate = new ComposerTemplate(GenericTaxesConstants.ComposerViewValue);
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
composerTemplate.LinkedEntities = new List <string>()
{
"Sitecore.Commerce.Plugin.Catalog.SellableItem"
};
composerTemplate.Name = "GenericTaxes";
composerTemplate.DisplayName = "Generic Taxes";
var composerTemplateViewComponent = composerTemplate.GetComponent <EntityViewComponent>();
var composerTemplateView = new EntityView
{
Name = "Generic Taxes",
DisplayName = "GenericTaxes",
DisplayRank = 0,
ItemId = itemId,
EntityId = composerTemplate.Id
};
GenericTaxPolicy taxPolicy = context.GetPolicy <GenericTaxPolicy>();
AvailableSelectionsPolicy availableSelectionsPolicy = new AvailableSelectionsPolicy();
foreach (decimal whiteListEntry in taxPolicy.Whitelist)
{
availableSelectionsPolicy.List.Add(new Selection()
{
Name = whiteListEntry.ToString(),
DisplayName = whiteListEntry.ToString(),
});
}
composerTemplateView.Properties.Add(new ViewProperty()
{
DisplayName = taxPolicy.TaxFieldName,
Name = taxPolicy.TaxFieldName,
OriginalType = "System.String",
RawValue = string.Empty,
Value = string.Empty,
Policies = new List <Policy>()
{
availableSelectionsPolicy
}
});
composerTemplateViewComponent.View.ChildViews.Add(composerTemplateView);
var persistResult = await this._commerceCommander.PersistEntity(context.CommerceContext, composerTemplate);
return(await Task.FromResult(true));
}
private async Task CreateManufacturerDataTemplate(CommercePipelineExecutionContext context)
{
var composerTemplate = new ComposerTemplate("Manufacturing".ToEntityId <ComposerTemplate>());
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
composerTemplate.LinkedEntities = new List <string>()
{
"Sitecore.Commerce.Plugin.Catalog.SellableItem"
};
composerTemplate.Name = "Manufacturing";
composerTemplate.DisplayName = "Manufacturing";
var composerTemplateViewComponent = composerTemplate.GetComponent <EntityViewComponent>();
var composerTemplateView = new EntityView
{
Name = "Manufacturing",
DisplayName = "Manufacturing",
DisplayRank = 0,
ItemId = $"Composer-{System.Guid.NewGuid()}",
EntityId = composerTemplate.Id
};
composerTemplateView.Properties.Add(new ViewProperty
{
Name = "CountryOfOrigin",
DisplayName = "Country of Origin",
OriginalType = "System.String",
});
composerTemplateView.Properties.Add(new ViewProperty
{
Name = "ManufacturerType",
DisplayName = "Manufacturer Type",
OriginalType = "System.String",
Policies = new List <Policy>
{
new AvailableSelectionsPolicy
{
List = new List <Selection>
{
new Selection
{
DisplayName = "Hand",
Name = "Hand"
},
new Selection
{
DisplayName = "Automated",
Name = "Automated"
}
}
}
}
});
composerTemplateViewComponent.View.ChildViews.Add(composerTemplateView);
await _commerceCommander.PersistEntity(context.CommerceContext, composerTemplate);
}
private void AddItemDefinitionsFromProxy(ComposerTemplate engineComposerTemplate, ProxyComposer.ComposerTemplate proxyComposerTemplate)
{
var proxyItemDefinitionsComponent = proxyComposerTemplate?.Components?.OfType <ProxyCatalog.ItemDefinitionsComponent>().FirstOrDefault();
if (proxyItemDefinitionsComponent == null)
{
return;
}
engineComposerTemplate.GetComponent <ItemDefinitionsComponent>().AddDefinitions(proxyItemDefinitionsComponent.Definitions);
}
private void AddTagsFromProxy(ComposerTemplate engineComposerTemplate, ProxyComposer.ComposerTemplate proxyComposerTemplate)
{
if (proxyComposerTemplate.Tags == null || !proxyComposerTemplate.Tags.Any())
{
return;
}
engineComposerTemplate.Tags = proxyComposerTemplate.Tags
.Select(pt => new Tag(pt.Name)
{
Excluded = false
})
.ToList();
}
private void AddComposerTemplateListMembershipsFromProxy(ComposerTemplate engineComposerTemplate, ProxyComposer.ComposerTemplate proxyComposerTemplate)
{
var proxyListMembershipComponent = proxyComposerTemplate?.Components?.OfType <ProxyManagedLists.ListMembershipsComponent>().FirstOrDefault();
if (proxyListMembershipComponent == null)
{
return;
}
foreach (var membership in proxyListMembershipComponent.Memberships)
{
engineComposerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(membership);
}
}
public virtual async Task CreateTemplateFromProxy(CommerceContext commerceContext, ProxyComposer.ComposerTemplate proxyComposerTemplate)
{
ComposerCommander composerCommander = this;
Condition.Requires(commerceContext).IsNotNull("CommerceContext");
Condition.Requires(proxyComposerTemplate).IsNotNull("composerTemplate");
using (CommandActivity.Start(commerceContext, composerCommander))
{
KnownResultCodes errorCodes = commerceContext.GetPolicy <KnownResultCodes>();
string composerTemplateName = proxyComposerTemplate.Name;
if (string.IsNullOrEmpty(composerTemplateName))
{
string composerTemplatePropertyName = "Name";
string str2 = await commerceContext.AddMessage(errorCodes.ValidationError, "InvalidOrMissingPropertyValue", new object[1]
{
composerTemplatePropertyName
}, "Invalid or missing value for property '" + composerTemplatePropertyName + "'.").ConfigureAwait(false);
return;
}
string templateId = proxyComposerTemplate.Id;
if (await composerCommander.GetEntity <ComposerTemplate>(commerceContext, templateId, false).ConfigureAwait(false) != null)
{
string str = await commerceContext.AddMessage(errorCodes.ValidationError, "NameAlreadyInUse", new object[1]
{
proxyComposerTemplate.Name
}, "Name '" + proxyComposerTemplate.Name + "' is already in use.").ConfigureAwait(false);
return;
}
ComposerTemplate engineComposerTemplate = new ComposerTemplate(templateId);
engineComposerTemplate.Name = proxyComposerTemplate.Name;
engineComposerTemplate.DisplayName = proxyComposerTemplate.DisplayName;
engineComposerTemplate.FriendlyId = proxyComposerTemplate.Name;
engineComposerTemplate.LinkedEntities = proxyComposerTemplate.LinkedEntities;
this.AddTagsFromProxy(engineComposerTemplate, proxyComposerTemplate);
this.AddComposerTemplateListMembershipsFromProxy(engineComposerTemplate, proxyComposerTemplate);
await this.AddComposerTemplateEntityViewFromProxy(commerceContext, engineComposerTemplate, proxyComposerTemplate);
this.AddItemDefinitionsFromProxy(engineComposerTemplate, proxyComposerTemplate);
int num = await composerCommander.PersistEntity(commerceContext, engineComposerTemplate).ConfigureAwait(false) ? 1 : 0;
errorCodes = null;
templateId = null;
}
}
/// <summary>
/// To Custom Composer Template
/// </summary>
/// <param name="input">Composer Template input</param>
/// <returns>Custom Composer Template output</returns>
public static CustomComposerTemplate ToCustomComposerTemplate(this ComposerTemplate input)
{
EntityView entityView = input.GetComponent <EntityViewComponent>().View.ChildViews.FirstOrDefault() as EntityView;
entityView.EntityId = string.IsNullOrEmpty(entityView.EntityId) ? entityView.EntityId : input.Id;
return(new CustomComposerTemplate()
{
EntityVersion = input.EntityVersion,
Id = input.Id,
Name = input.Name,
DisplayName = input.DisplayName,
Version = input.Version,
LinkedEntities = input.LinkedEntities,
ChildView = entityView.ToCustomEntityView()
});
}
private async Task CreateSizingTemplate(CommercePipelineExecutionContext context)
{
var composerTemplate = new ComposerTemplate("Sizing".ToEntityId <ComposerTemplate>());
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
composerTemplate.LinkedEntities = new List <string>()
{
"Sitecore.Commerce.Plugin.Catalog.SellableItem"
};
composerTemplate.Name = "Sizing";
composerTemplate.DisplayName = "Sizing";
var composerTemplateViewComponent = composerTemplate.GetComponent <EntityViewComponent>();
var composerTemplateView = new EntityView
{
Name = "Sizing",
DisplayName = "Sizing Data",
DisplayRank = 0,
ItemId = $"Composer-{System.Guid.NewGuid()}",
EntityId = composerTemplate.Id
};
composerTemplateView.Properties.Add(new ViewProperty
{
Name = "Waist",
DisplayName = "Waist",
OriginalType = "System.Int64",
});
composerTemplateView.Properties.Add(new ViewProperty
{
Name = "InsideLeg",
DisplayName = "Inside Leg",
OriginalType = "System.Int64",
});
composerTemplateView.Properties.Add(new ViewProperty
{
Name = "OutsideLeg",
DisplayName = "Outside Leg",
OriginalType = "System.Int64",
});
composerTemplateViewComponent.View.ChildViews.Add(composerTemplateView);
await _commerceCommander.PersistEntity(context.CommerceContext, composerTemplate);
}
/// <summary>
/// To Composer Template
/// </summary>
/// <param name="input">Custom Composer Template</param>
/// <returns>Composer Tewmplate</returns>
public static ComposerTemplate ToComposerTemplate(this CustomComposerTemplate input)
{
var composerTemplate = new ComposerTemplate(input.Id);
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
composerTemplate.LinkedEntities = input.LinkedEntities;
composerTemplate.Name = input.Name;
composerTemplate.DisplayName = input.DisplayName;
composerTemplate.Version = input.Version;
composerTemplate.EntityVersion = input.EntityVersion;
var composerTemplateViewComponent = composerTemplate.GetComponent <EntityViewComponent>();
composerTemplateViewComponent.View.ChildViews.Add(input.ChildView.ToEntityView());
return(composerTemplate);
}
public override async Task <ComposerTemplateContentArgument> Run(CreateComposerTemplateArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires <CreateComposerTemplateArgument>(arg).IsNotNull <CreateComposerTemplateArgument>($"{this.Name}: The argument can not be null");
var composerTemplateId = $"{CommerceEntity.IdPrefix<ComposerTemplate>()}{arg.ComposerTemplateId}";
var errorCodes = context.GetPolicy <KnownResultCodes>();
if (await _doesEntityExistPipeline.Run(new FindEntityArgument(typeof(ComposerTemplate), composerTemplateId), context.CommerceContext.PipelineContextOptions))
{
var errorMessage = await context.CommerceContext.AddMessage(errorCodes.ValidationError,
"NameAlreadyInUse", new object[1] {
arg.ComposerTemplateId
},
$"Name '{arg.ComposerTemplateId}' is already in use.");
return(new ComposerTemplateContentArgument());
}
var composerTemplate = new ComposerTemplate(composerTemplateId)
{
Name = !string.IsNullOrEmpty(arg.Name) ? arg.Name : arg.ComposerTemplateId,
DisplayName = arg.DisplayName,
FriendlyId = arg.ComposerTemplateId
};
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
var entityView = CreateEntityView(context.CommerceContext, arg.ComposerTemplateId, arg.Name, arg.DisplayName);
if (entityView != null)
{
composerTemplate.GetComponent <EntityViewComponent>().AddChildView(entityView);
}
var persistResult = await _persistEntityPipeline.Run(new PersistEntityArgument(composerTemplate), context.CommerceContext.PipelineContextOptions);
return(new ComposerTemplateContentArgument()
{
ComposerTemplate = persistResult?.Entity as ComposerTemplate
});
}
public void Init()
{
instance = new ComposerTemplate();
}
private async Task AddComposerTemplateEntityViewFromProxy(CommerceContext commerceContext, ComposerTemplate engineComposerTemplate, ProxyComposer.ComposerTemplate proxyComposerTemplate)
{
var proxyEntityViewComponent = proxyComposerTemplate.Components.OfType <ProxyViews.EntityViewComponent>().FirstOrDefault();
if (proxyEntityViewComponent == null ||
proxyEntityViewComponent.View == null ||
proxyEntityViewComponent.View.ChildViews == null ||
!proxyEntityViewComponent.View.ChildViews.Any())
{
return;
}
var proxyChildView = proxyEntityViewComponent.View?.ChildViews[0] as ProxyEntityViews.EntityView;
EntityView engineEntityChildView = new EntityView();
engineEntityChildView.ItemId = proxyChildView.ItemId;
engineEntityChildView.EntityId = proxyChildView.EntityId;
engineEntityChildView.Name = proxyChildView?.Name;
engineEntityChildView.DisplayName = proxyChildView.DisplayName;
engineEntityChildView.Icon = proxyChildView.Icon;
engineEntityChildView.DisplayRank = proxyChildView.DisplayRank;
var isNameValid = await this.RunValidCheckOnName(engineEntityChildView, commerceContext);
if (!isNameValid)
{
return;
}
engineComposerTemplate.GetComponent <EntityViewComponent>().AddChildView(engineEntityChildView);
if (proxyChildView.Properties != null)
{
foreach (var proxyViewProperty in proxyChildView.Properties)
{
await this.AddPropertyToViewFromProxy(commerceContext, engineEntityChildView, proxyViewProperty);
}
}
}
private async void CreateBlockchainInformationTemplate(CommercePipelineExecutionContext context)
{
string templateId = $"{CommerceEntity.IdPrefix<ComposerTemplate>()}{"BlockchainInformation"}";
try
{
// delete the existing template (this does not delete data from products)
var deleteTemplate = await _commerceCommander.DeleteEntity(context.CommerceContext, templateId);
var composerTemplate = new ComposerTemplate(templateId);
composerTemplate.GetComponent <ListMembershipsComponent>().Memberships.Add(CommerceEntity.ListName <ComposerTemplate>());
composerTemplate.Tags.Add(new Tag("Blockchain"));
composerTemplate.Name = "BlockchainInformation";
composerTemplate.DisplayName = "Blockchain Information";
var composerTemplateViewComponent = composerTemplate.GetComponent <EntityViewComponent>();
composerTemplateViewComponent.Id = "95DACDDD-151E-4527-A068-A27C9275967J";
var composerTemplateView = new EntityView
{
Name = Constants.Pipelines.Views.BlockchainInformationViewName,
DisplayName = Constants.Pipelines.Views.BlockchainInformationViewDisplayName,
DisplayRank = 0,
ItemId = Constants.Pipelines.Views.BlockchainInformationViewId,
EntityId = composerTemplate.Id
};
composerTemplateView.Properties.Add(new ViewProperty()
{
IsRequired = false,
DisplayName = "Identity Contract Address",
Name = Constants.Pipelines.Fields.IdentityContractAddressFieldName,
OriginalType = "System.String",
RawValue = "",
Value = ""
});
composerTemplateView.Properties.Add(new ViewProperty()
{
IsRequired = false,
DisplayName = "Publish Purchased Products",
Name = Constants.Pipelines.Fields.PublishProductsFieldName,
OriginalType = "System.Boolean",
RawValue = false,
Value = "false"
});
composerTemplateView.Properties.Add(new ViewProperty()
{
IsRequired = false,
DisplayName = "ETH Balance",
Name = Constants.Pipelines.Fields.EthBalanceFieldName,
OriginalType = "System.String",
RawValue = string.Empty,
Value = string.Empty,
IsReadOnly = true
});
composerTemplateViewComponent.View.ChildViews.Add(composerTemplateView);
var persistResult = await this._commerceCommander.PersistEntity(context.CommerceContext, composerTemplate);
}
catch (Exception ex)
{
context.Logger.LogError(string.Format("{0}. Unable to generate Composer tamplate '{1}'. {2}", Constants.Pipelines.Blocks.CreateComposerTemplatesBlock, templateId, ex.Message), Array.Empty <object>());
}
}
private async Task UpdateSyncforceComposerTemplate(SynchronizeProductArgument arg,
CommercePipelineExecutionContext context, SellableItem sellableItem, ComposerTemplate commonComposerTemplate,
SyncForceClientPolicy syncForcePolicy)
{
var sellableEntityViewComponent = sellableItem.GetComponent <EntityViewComponent>();
if (sellableEntityViewComponent != null)
{
EntityView tempViewHolder = new EntityView();
tempViewHolder.SetPropertyValue("Template", syncForcePolicy.CommonComposerTemplateName);
tempViewHolder.GetProperty(it =>
String.Equals(it.Name, "Template", StringComparison.InvariantCultureIgnoreCase)).Value =
syncForcePolicy.CommonComposerTemplateName;
EntityView templateView = !string.IsNullOrEmpty(tempViewHolder.ItemId) ? sellableItem.GetComponent <EntityViewComponent>().ChildViewWithItemId(tempViewHolder.ItemId) : sellableItem.GetComponent <EntityViewComponent>().View.ChildViews.OfType <EntityView>().FirstOrDefault <EntityView>();
if (templateView == null || !sellableItem.GetComponent <EntityViewComponent>().HasChildViews((Func <EntityView, bool>)(p => p.Name.Equals(templateView.Name, StringComparison.OrdinalIgnoreCase))))
{
await _composerCommander.AddChildViewFromTemplate(context.CommerceContext, tempViewHolder, sellableItem);
}
var composerView = sellableItem.GetComponent <EntityViewComponent>()?.View.ChildViews?.OfType <EntityView>()
?.FirstOrDefault(v => v.Name == syncForcePolicy.CommonComposerTemplateName);
if (composerView != null)
{
//Add SyncForce timestamp
var timestampDateTime = DateTime.SpecifyKind(arg.MasterProduct.TimeStamp, DateTimeKind.Utc);
var timestampDateTimeOffset = (DateTimeOffset)timestampDateTime;
var timestampRawValue = timestampDateTimeOffset.ToString("yyyy-MM-dd'T'H:mm:ss.fffffffzzz");
//Ensure timestamp field on ComposerTemplate
await EnsureComposerTemplateProperty(syncForcePolicy, commonComposerTemplate, context.CommerceContext, composerView, "Timestamp", "System.DateTimeOffset");
if (composerView.ContainsProperty("Timestamp"))
{
composerView.SetPropertyValue("Timestamp", timestampRawValue);
}
else
{
composerView.Properties.Add(new ViewProperty()
{
DisplayName = "Timestamp",
RawValue = timestampRawValue,
IsHidden = false,
IsReadOnly = false,
IsRequired = false,
Name = "Timestamp",
OriginalType = "System.DateTimeOffset"
});
}
}
}
}
private async Task <ComposerTemplate> EnsureComposerTemplateProperty(SyncForceClientPolicy syncForcePolicy, ComposerTemplate template, CommerceContext context, EntityView childView, string name, string propertyType)
{
var entityViewComponent = template.GetComponent <EntityViewComponent>();
if (childView.Properties.All(p => p.Name != name))
{
if (entityViewComponent.View.GetChildView(
it => String.Equals(it.Name, syncForcePolicy.CommonComposerTemplateName, StringComparison.InvariantCultureIgnoreCase)) is EntityView templateView)
{
templateView.Properties.Add(new ViewProperty()
{
DisplayName = name,
IsHidden = false,
OriginalType = propertyType,
IsRequired = false,
IsReadOnly = false,
Name = name
});
template.SetComponent(entityViewComponent);
return((await _persistEntityPipeline.Run(new PersistEntityArgument(template),
context.PipelineContextOptions))?.Entity as ComposerTemplate);
}
}
return(template);
}
