public async Task <bool> Process(CommerceContext commerceContext, string id)
{
using (var activity = CommandActivity.Start(commerceContext, this))
{
Setting setting = await _commerceCommander.Command <GetSettingCommand>().Process(commerceContext, id);
if (setting == null)
{
return(false);
}
setting.IsActive = true;
await _commerceCommander.PersistEntity(commerceContext, setting);
CommerceList <Setting> settings = await _commerceCommander.Command <FindEntitiesInListCommand>().Process <Setting>(commerceContext, CommerceEntity.ListName <Setting>(), 0, int.MaxValue);
foreach (var listSetting in settings.Items)
{
if (listSetting.Id.Equals(setting.Id))
{
continue;
}
listSetting.IsActive = false;
await _commerceCommander.PersistEntity(commerceContext, listSetting);
}
}
return(true);
}
private async Task ReserveIt(CommerceContext commerceContext, string id)
{
var entity = await _commander.GetEntity <CommerceEntity>(commerceContext, id, autoCreate : true);
entity.Id = id;
await _commander.PersistEntity(commerceContext, entity);
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="arg">The SampleArgument argument.</param>
/// <param name="context">The context.</param>
/// <returns>The <see cref="SampleEntity"/>.</returns>
public override async Task <SampleEntity> Run(TransactionArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{Name}: The argument can not be null");
var result = new SampleEntity()
{
Id = $"{CommerceEntity.IdPrefix<SampleEntity>()}Inner-{Guid.NewGuid().ToString()}"
};
await Commander.PersistEntity(context.CommerceContext, result).ConfigureAwait(false);
if (arg.ErrorOnInnerScope)
{
context.Abort(
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().ValidationError,
"ForcedError",
new object[] { nameof(arg.ErrorOnInnerScope) },
$"Error in {nameof(arg.ErrorOnInnerScope)}.").ConfigureAwait(false),
context);
return(null);
}
return(result);
}
public async Task <Setting> Process(CommerceContext commerceContext, CreateSettingArg arg)
{
using (var activity = CommandActivity.Start(commerceContext, this))
{
var setting = new Setting
{
Id = arg.Name.ToEntityId <Setting>(),
DisplayName = arg.DisplayName,
Name = arg.Name,
IsActive = false
};
var listMemberShipComponent = setting.GetComponent <ListMembershipsComponent>();
if (!listMemberShipComponent.Memberships.Contains(CommerceEntity.ListName <Setting>()))
{
listMemberShipComponent.Memberships.Add(CommerceEntity.ListName <Setting>());
setting.SetComponent(listMemberShipComponent);
}
var transientListMembershipComponent = setting.GetComponent <TransientListMembershipsComponent>();
if (!transientListMembershipComponent.Memberships.Contains(CommerceEntity.ListName <Setting>()))
{
transientListMembershipComponent.Memberships.Add(CommerceEntity.ListName <Setting>());
setting.SetComponent(transientListMembershipComponent);
}
var persistResult = await _commerceCommander.PersistEntity(commerceContext, setting);
return(persistResult
? setting
: null);
}
}
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);
}
public async Task <bool> Process(CommerceContext commerceContext, string id)
{
using (var activity = CommandActivity.Start(commerceContext, this))
{
Setting setting = await _commerceCommander.Command <GetSettingCommand>().Process(commerceContext, id);
if (setting == null)
{
return(false);
}
setting.IsActive = false;
await _commerceCommander.PersistEntity(commerceContext, setting);
}
return(true);
}
public override async Task <EntityView> Run(EntityView entityView, CommercePipelineExecutionContext context)
{
if (entityView == null || !entityView.Action.Contains("Roles.DisablePlugin"))
{
return(entityView);
}
try
{
var pluginName = entityView.Action.Replace("Roles.DisablePlugin.", "");
var userPluginOptions = await _commerceCommander.Command <PluginCommander>().CurrentUserSettings(context.CommerceContext, _commerceCommander);
userPluginOptions.EnabledPlugins.Remove(pluginName);
await _commerceCommander.PersistEntity(context.CommerceContext, userPluginOptions);
}
catch (Exception ex)
{
context.Logger.LogError($"Catalog.DoActionAddDashboardEntity.Exception: Message={ex.Message}");
}
return(entityView);
}
/// <summary>
/// Runs the specified argument.
/// </summary>
/// <param name="arg">The argument.</param>
/// <param name="context">The context.</param>
/// <returns>The <see cref="Order"/></returns>
public override async Task <Order> Run(Order arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{Name}: The order cannot be null.");
if (!arg.HasComponent <FederatedPaymentComponent>() ||
!arg.Status.Equals(context.GetPolicy <KnownOrderStatusPolicy>().Released, StringComparison.OrdinalIgnoreCase))
{
return(arg);
}
var knownOrderStatuses = context.GetPolicy <KnownOrderStatusPolicy>();
var payment = arg.GetComponent <FederatedPaymentComponent>();
var salesActivityReference = arg.SalesActivity.FirstOrDefault(sa => sa.Name.Equals(payment.Id, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(payment.TransactionId) || salesActivityReference == null)
{
payment.TransactionStatus = knownOrderStatuses.Problem;
arg.Status = knownOrderStatuses.Problem;
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[]
{
"TransactionId"
},
"Invalid or missing value for property 'TransactionId'.")
.ConfigureAwait(false);
return(arg);
}
var salesActivity = await _commander
.GetEntity <SalesActivity>(context.CommerceContext, salesActivityReference.EntityTarget, salesActivityReference.EntityTargetUniqueId)
.ConfigureAwait(false);
if (salesActivity == null)
{
payment.TransactionStatus = knownOrderStatuses.Problem;
arg.Status = knownOrderStatuses.Problem;
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"EntityNotFound",
new object[]
{
salesActivityReference.EntityTarget
},
$"Entity '{salesActivityReference.EntityTarget}' was not found.")
.ConfigureAwait(false);
return(arg);
}
var knowSalesActivitiesStatus = context.GetPolicy <KnownSalesActivityStatusesPolicy>();
if (payment.TransactionStatus.Equals(knownOrderStatuses.Problem, StringComparison.OrdinalIgnoreCase))
{
salesActivity.PaymentStatus = knowSalesActivitiesStatus.Problem;
}
await SettleSalesActivity(salesActivity, context).ConfigureAwait(false);
payment.TransactionStatus = salesActivity.GetComponent <FederatedPaymentComponent>().TransactionStatus;
if (salesActivity.PaymentStatus.Equals(knowSalesActivitiesStatus.Problem, StringComparison.OrdinalIgnoreCase))
{
arg.Status = knownOrderStatuses.Problem;
}
var knownSalesActivityLists = context.GetPolicy <KnownOrderListsPolicy>();
var listToAssignTo = !salesActivity.PaymentStatus.Equals(knowSalesActivitiesStatus.Settled, StringComparison.OrdinalIgnoreCase)
? knownSalesActivityLists.ProblemSalesActivities
: knownSalesActivityLists.SettledSalesActivities;
var argument = new MoveEntitiesInListsArgument(knownSalesActivityLists.SettleSalesActivities, listToAssignTo, new List <string>
{
salesActivity.Id
});
await _commander.Pipeline <IMoveEntitiesInListsPipeline>().Run(argument, context.CommerceContext.PipelineContextOptions).ConfigureAwait(false);
await _commander.PersistEntity(context.CommerceContext, salesActivity).ConfigureAwait(false);
return(arg);
}
public async override Task <EntityView> Run(EntityView entityView, CommercePipelineExecutionContext context)
{
string targetId = string.IsNullOrEmpty(entityView.EntityId)
? entityView.ItemId
: entityView.EntityId;
var setting = await _commerceCommander.Command <GetSettingCommand>().Process(context.CommerceContext, targetId);
if (setting == null)
{
return(entityView);
}
var policies = _commerceCommander.Command <PolicyCollectionCommand>().Process(context.CommerceContext);
foreach (var policy in policies)
{
string actionName = policy.GetActionName();
if (entityView == null || !entityView.Action.Equals(actionName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
try
{
var policyFromSetting = setting.EntityPolicies.FirstOrDefault(element => element.GetType().FullName.Equals(policy.FullName));
if (policyFromSetting == null)
{
policyFromSetting = Activator.CreateInstance(policy) as Policy;
}
foreach (var property in policyFromSetting.GetType().GetProperties())
{
var editorSetting = property.GetCustomAttribute <EditorSettingAttribute>();
if (editorSetting == null)
{
continue;
}
string formValue = entityView.Properties.FirstOrDefault(element => element.Name.Equals(editorSetting.DisplayName))?.Value ?? string.Empty;
var propertyValue = property.GetValue(policyFromSetting);
if (propertyValue is IList <string> )
{
property.SetValue(policyFromSetting, formValue.Split('|'));
}
else if (propertyValue is int)
{
if (int.TryParse(formValue, out int mappedFormValue))
{
property.SetValue(policyFromSetting, mappedFormValue);
}
}
else if (propertyValue is bool)
{
if (bool.TryParse(formValue, out bool mappedFormValue))
{
property.SetValue(policyFromSetting, mappedFormValue);
}
}
else
{
property.SetValue(policyFromSetting, formValue);
}
}
setting.SetPolicy(policyFromSetting);
bool success = await _commerceCommander.PersistEntity(context.CommerceContext, setting);
return(entityView);
}
catch (Exception ex)
{
context.Logger.LogError($"{this.Name}.PathNotFound: Message={ex.Message}");
}
}
return(entityView);
}
public async Task <EntityView> ExecuteRun <T>(EntityView entityView, CommercePipelineExecutionContext context, string actionName) where T : Policy
{
if (entityView == null ||
!entityView.Action.Equals(actionName, StringComparison.OrdinalIgnoreCase))
{
return(entityView);
}
string targetId = string.IsNullOrEmpty(entityView.EntityId)
? entityView.ItemId
: entityView.EntityId;
try
{
var setting = await _commerceCommander.Command <GetSettingCommand>().Process(context.CommerceContext, targetId);
if (setting == null)
{
return(entityView);
}
var importerPolicy = setting.GetPolicy <T>();
foreach (var property in importerPolicy.GetType().GetProperties())
{
var editorSetting = property.GetCustomAttribute <EditorSettingAttribute>();
if (editorSetting == null)
{
continue;
}
string formValue = entityView.Properties.FirstOrDefault(element => element.Name.Equals(editorSetting.DisplayName))?.Value ?? string.Empty;
var propertyValue = property.GetValue(importerPolicy);
if (propertyValue is IList <string> )
{
property.SetValue(importerPolicy, formValue.Split('|'));
}
else if (propertyValue is int)
{
if (int.TryParse(formValue, out int mappedFormValue))
{
property.SetValue(importerPolicy, mappedFormValue);
}
}
else
{
property.SetValue(importerPolicy, formValue);
}
}
bool success = await _commerceCommander.PersistEntity(context.CommerceContext, setting);
}
catch (Exception ex)
{
context.Logger.LogError($"{this.Name}.PathNotFound: Message={ex.Message}");
}
return(entityView);
}
