/// <summary>
/// Upgrades customers in list.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="listName">Name of the list.</param>
/// <param name="skip">The skip.</param>
/// <param name="take">The take.</param>
/// <returns>Number of migrated customers</returns>
protected virtual async Task <int> UpgradeCustomersInList(CommercePipelineExecutionContextOptions context, string listName, int skip, int take)
{
var findResult = await this._findEntitiesInListPipeline.Run(new FindEntitiesInListArgument(typeof(Customer), listName, skip, take) { LoadEntities = true }, context).ConfigureAwait(false);
if (findResult?.List?.Items == null || !findResult.List.Items.Any())
{
return(0);
}
foreach (var item in findResult.List.Items)
{
var customer = (Customer)item;
if (!string.IsNullOrEmpty(customer.UserName))
{
continue;
}
var cloneContext = this.CloneCommerceContext(context.CommerceContext);
await this._upgradeCustomerPipeline.Run(customer, cloneContext).ConfigureAwait(false);
MergeMessages(context.CommerceContext, cloneContext.CommerceContext);
}
return(findResult.List.Items.Count);
}
protected override async Task <MinionRunResultsModel> Execute()
{
int itemsProcessed = 0;
var orders = await GetListItems <Order>(Policy.ListToWatch, Policy.ItemsPerBatch).ConfigureAwait(false);
foreach (Order order in orders)
{
CommerceContext commerceContext = new CommerceContext(Logger, MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null)
{
Environment = Environment
};
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext);
await MinionPipeline.Run(order, executionContextOptions);
itemsProcessed++;
}
return(new MinionRunResultsModel
{
DidRun = true,
ItemsProcessed = itemsProcessed
});
}
public override async Task <MinionRunResultsModel> Run()
{
MinionRunResultsModel result = new MinionRunResultsModel();
Logger.LogTrace($"{this.Name}: Invoked.");
string listName = Policy.ListToWatch;
Task <long> itemCount = GetListCount(listName);
//TODO correct handling of <cref='MinionResultArgument.HasMoreItems'>HasMoreItems</cref>
IEnumerable <CommerceEntity> entities = await GetListItems <CommerceEntity>(listName, Policy.ItemsPerBatch);
foreach (Customer customer in entities.OfType <Customer>())
{
var executionContext = new CommercePipelineExecutionContextOptions(
new CommerceContext(MinionContext.Logger, MinionContext.TelemetryClient)
{
Environment = this.Environment
});
var issueCouponArgument = new IssueCouponArgument {
Customer = customer
};
var pipelineResult = await this.MinionPipeline.Run(issueCouponArgument, executionContext);
// TODO Appropriate handling of pipeline status. Look at other minions.
result.ItemsProcessed++;
}
return(result);
}
public override async Task <MinionRunResultsModel> Run()
{
long listCount = await GetListCount(Policy.ListToWatch);
if (listCount > 0L)
{
var jobInstanceList = (await this.GetListItems <JobInstance>(this.Policy.ListToWatch, this.Policy.ItemsPerBatch)).ToList();
foreach (var jobInstance in jobInstanceList)
{
if (jobInstance.ScheduleDateTime < DateTime.Now)
{
this.Logger.LogInformation($"Starting job {jobInstance.Job.Name}");
jobInstance.StartDateTime = DateTime.Now;
var jobsSchedulerArgument = new JobSchedulerArgument(jobInstance);
var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient)
{
Environment = this.Environment
};
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext);
var job = await JobSchedulerPipeline.Run(jobsSchedulerArgument, executionContextOptions);
}
}
}
return(new MinionRunResultsModel());
}
protected override async Task <MinionRunResultsModel> Execute()
{
MinionRunResultsModel runResults = new MinionRunResultsModel();
/*Gets all the ReleasedOrders and executes export order*/
long listCount = await GetListCount(Policy.ListToWatch).ConfigureAwait(false);
this.Logger.LogInformation(string.Format(CultureInfo.InvariantCulture, "{0}-Review List {1}: Count:{2}", Name, Policy.ListsToWatch, listCount));
foreach (var listItems in (await GetListItems <XC.Order>(Policy.ListToWatch, Convert.ToInt32(listCount)).ConfigureAwait(false)))
{
this.Logger.LogDebug(string.Format(CultureInfo.InvariantCulture, "{0}-Reviewing Pending Order: {1}", listItems.Name, listItems.Id), Array.Empty <object>());
var minionPipeline = ExportOrderPipeline;
var ordersMinionArgument = new ExportOrderArgument(listItems.Id);
using (var commerceContext = new CommerceContext(Logger, MinionContext.TelemetryClient, null))
{
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
var order = await minionPipeline.Run(ordersMinionArgument, executionContextOptions).ConfigureAwait(false);
}
}
return(runResults);
}
protected override async Task <MinionRunResultsModel> Execute()
{
MinionRunResultsModel runResults = new MinionRunResultsModel();
/* Pull from an appropriate list and execute an appropriate pipeline. */
/*Gets list of Items from ReleasedOrders and executes export order to file block*/
long listCount = await this.GetListCount(this.Policy.ListToWatch).ConfigureAwait(false);
this.Logger.LogInformation(string.Format("{0}-Review List {1}: Count:{2}", Name, Policy.ListToWatch, listCount));
foreach (var commerceEnty in (await this.GetListItems <XC.Order>(Policy.ListToWatch, Convert.ToInt32(listCount)).ConfigureAwait(false)))
{
this.Logger.LogDebug(string.Format("{0}-Reviewing Pending Order: {1}", commerceEnty.Name, commerceEnty.Id), Array.Empty <object>());
var minionPipeline = ExportOrderPipeline;
var ordersMinionArgument = new ExportOrderArgument(commerceEnty.Id);
using (var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, null))
{
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
var order = await minionPipeline.Run(ordersMinionArgument, executionContextOptions).ConfigureAwait(false);
}
}
return(runResults);
}
public override async Task <MinionRunResultsModel> Run()
{
MinionRunResultsModel result = new MinionRunResultsModel();
Logger.LogTrace($"{this.Name}: Invoked.");
string listName = Policy.ListToWatch;
Task <long> itemCount = GetListCount(listName);
//TODO correct handling of <cref='MinionResultArgument.HasMoreItems'>HasMoreItems</cref>
IEnumerable <CommerceEntity> entities = await GetListItems <CommerceEntity>(listName, Policy.ItemsPerBatch);
foreach (Customer customer in entities.OfType <Customer>())
{
await this.CommerceCommand.PerformTransaction(MinionContext, async() =>
{
var executionContext = new CommercePipelineExecutionContextOptions(
new CommerceContext(MinionContext.Logger, MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null)
{
Environment = this.Environment
});
var pipelineResult = await this.MinionPipeline.Run(customer, executionContext);
//TODO Think about error handling here. What happens if the transaction times out?
});
result.ItemsProcessed++;
}
return(result);
}
protected override async Task <MinionRunResultsModel> Execute()
{
MinionRunResultsModel runResults = new MinionRunResultsModel();
/* STUDENT: Complete the body of this method. You need to pull from an appropriate list
* and then execute an appropriate pipeline. */
long listCount = await GetListCount(Policy.ListToWatch).ConfigureAwait(false);
this.Logger.LogInformation(string.Format("{0}-Review List {1}: Count:{2}", (object)this.Name, (object)this.Policy.ListToWatch, (object)listCount));
// var entitleMentList = await this.GetListIds<XC.Order>(this.Policy.ListToWatch, Convert.ToInt32(listCount)).ConfigureAwait(false);
foreach (var commerceEnty in (await this.GetListItems <XC.Order>(Policy.ListToWatch, Convert.ToInt32(listCount)).ConfigureAwait(false)))
{
this.Logger.LogDebug(string.Format("{0}-Reviewing Pending Order: {1}", commerceEnty.Name, commerceEnty.Id), Array.Empty <object>());
var minionPipeline = ExportOrderPipeline;
var ordersMinionArgument = new ExportOrderArgument(commerceEnty.Id);
using (var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null))
{
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
var order = await minionPipeline.Run(ordersMinionArgument, executionContextOptions).ConfigureAwait(false);
}
}
return(runResults);
}
public async Task <IEnumerable <PolicySnapshotModel> > Process(CommerceContext commerceContext)
{
IEnumerable <PolicySnapshotModel> policies;
using (CommandActivity.Start(commerceContext, this))
{
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
policies = await this.getPoliciesPipeline.Run(string.Empty, (IPipelineExecutionContextOptions)pipelineContextOptions);
}
return(policies);
}
protected virtual async Task Log(ImportEntityCommand command)
{
var commercePipelineExecutionContextOptions = new CommercePipelineExecutionContextOptions(
new CommerceContext(CommerceContext.Logger, CommerceContext.TelemetryClient)
{
Environment = CommerceContext.Environment
});
await ServiceProvider.GetService <ILogEntityImportResultPipeline>()
.Run(new LogEntityImportResultArgument(command), commercePipelineExecutionContextOptions)
.ConfigureAwait(false);
}
public virtual async Task <Cart> Process(CommerceContext commerceContext, string wishlistId, CartLineComponent line)
{
RemoveWishListLineCommand removeCartLineCommand = this;
Activity activity;
Cart result = null;
activity = CommandActivity.Start(commerceContext, removeCartLineCommand);
try
{
CommercePipelineExecutionContextOptions context = commerceContext.PipelineContextOptions;
FindEntityArgument findEntityArgument = new FindEntityArgument(typeof(Cart), wishlistId, false);
Cart cart = await removeCartLineCommand._getPipeline.Run(findEntityArgument, context).ConfigureAwait(false) as Cart;
if (cart == null)
{
string str = await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "EntityNotFound", new object[1]
{
wishlistId
}, string.Format("Entity {0} was not found.", wishlistId)).ConfigureAwait(false);
return(null);
}
if (cart.Lines.FirstOrDefault((c => c.Id == line.Id)) == null)
{
string str = await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "CartLineNotFound", new object[1]
{
line.Id
}, string.Format("Wishlist line {0} was not found", line.Id)).ConfigureAwait(false);
return(cart);
}
await removeCartLineCommand.PerformTransaction(commerceContext, async() =>
{
var cartResult = await this._pipeline.Run(new CartLineArgument(cart, line), (IPipelineExecutionContextOptions)context).ConfigureAwait(false);
result = cartResult;
});
return(result);
}
finally
{
if (activity != null)
{
activity.Dispose();
}
}
}
public override async Task <MinionRunResultsModel> Run()
{
this.Logger.LogInformation("ImportMinion running");
var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, null);
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
MinionRunResultsModel res = await this.MinionPipeline.Run(new MinionRunResultsModel(), executionContextOptions);
return(new MinionRunResultsModel());
}
public virtual async Task <CommerceEntity> Process(
CommerceContext commerceContext,
string itemId,
bool filterVariations)
{
using (CommandActivity.Start(commerceContext, this))
{
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
if (itemId.Contains("|"))
{
itemId = itemId.Replace("|", ",");
}
if (!string.IsNullOrEmpty(itemId))
{
if (itemId.Split(',').Length == 3)
{
var strArray = itemId.Split(',');
ProductArgument productArgument = new ProductArgument(strArray[0], strArray[1])
{
VariantId = strArray[2]
};
var sellableItem = await _pipeline.Run(productArgument, pipelineContextOptions).ConfigureAwait(false);
var catalog = await _findEntityPipeline.Run(new FindEntityArgument(typeof(Catalog), CommerceEntity.IdPrefix <Catalog>() + productArgument.CatalogName), pipelineContextOptions).ConfigureAwait(false) as Catalog;
if (catalog != null && sellableItem != null && sellableItem.HasPolicy <PriceCardPolicy>())
{
var priceCardName = sellableItem.GetPolicy <PriceCardPolicy>();
string entityId = $"{CommerceEntity.IdPrefix<PriceCard>()}{catalog.PriceBookName}-{priceCardName.PriceCardName}";
CommerceEntity commerceEntity = await _findEntityPipeline.Run(new FindEntityArgument(typeof(PriceCard), entityId), pipelineContextOptions).ConfigureAwait(false);
return(commerceEntity);
}
}
}
string str = await pipelineContextOptions.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().Error, "ItemIdIncorrectFormat", new object[]
{
itemId
}, "Expecting a CatalogId and a ProductId in the ItemId: " + itemId);
return(null);
}
}
public async Task <List <NearestStoreLocation> > Process(CommerceContext commerceContext, GetNearestStoreDetailsByLocationArgument inputArgumentList)
{
GetNearestStoreDetailsByLocationCommand getNearestStoreDetailsByLocationCommand = this;
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
//InventorySet result = (InventorySet)null;
List <NearestStoreLocation> sets = new List <NearestStoreLocation>();
using (CommandActivity.Start(commerceContext, (CommerceCommand)getNearestStoreDetailsByLocationCommand))
{
sets = await getNearestStoreDetailsByLocationCommand._getNearestStoreDetailsByLocationPipeline.Run(inputArgumentList, pipelineContextOptions);
}
return(sets);
}
public virtual async Task <Cart> Process(CommerceContext commerceContext, string wishlistId, CartLineComponent line)
{
AddWishListLineItemCommand addCartLineCommand = this;
Cart result = null;
using (CommandActivity.Start(commerceContext, addCartLineCommand))
{
await addCartLineCommand.PerformTransaction(commerceContext, async() =>
{
FindEntityArgument findEntityArgument = new FindEntityArgument(typeof(Cart), wishlistId, true);
CommercePipelineExecutionContextOptions context = commerceContext.GetPipelineContextOptions();
Cart cart = await _getPipeline.Run(findEntityArgument, commerceContext.GetPipelineContextOptions()).ConfigureAwait(false) as Cart;
if (cart == null)
{
string str = await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "EntityNotFound", new object[1]
{
wishlistId
}, $"Entity {wishlistId} was not found.");
}
else
{
if (!cart.IsPersisted)
{
cart.Id = wishlistId;
cart.Name = wishlistId;
cart.ShopName = commerceContext.CurrentShopName();
cart.SetComponent(new ListMembershipsComponent()
{
Memberships = new List <string>
{
CommerceEntity.ListName <Cart>()
}
});
cart.SetComponent(new CartTypeComponent {
CartType = CartTypeEnum.Wishlist.ToString()
});
}
result = await _addWishListLineItemPipeline.Run(new CartLineArgument(cart, line), context);
}
});
}
return(result);
}
protected virtual async Task <Order> GetLoyaltyOrder(CommerceContext context, string orderId)
{
if (string.IsNullOrEmpty(orderId))
{
return(null);
}
var options = new CommercePipelineExecutionContextOptions(context);
var loyaltyOrder = await _getLoyaltyOrderPipeline.Run(orderId, options);
if (loyaltyOrder == null)
{
context.Logger.LogDebug($"Order {orderId} was not found.");
}
return(loyaltyOrder);
}
public virtual async Task <IEnumerable <ComposerTemplate> > Process(CommerceContext commerceContext, string[] templateIds)
{
GetComposerTemplatesCommand getComposerTemplatesCommand = this;
IEnumerable <ComposerTemplate> composerTemplates = Enumerable.Empty <ComposerTemplate>();
GetComposerTemplatesArgument getComposerTemplatesArgument = new GetComposerTemplatesArgument(templateIds);
using (CommandActivity.Start(commerceContext, getComposerTemplatesCommand))
{
await getComposerTemplatesCommand.PerformTransaction(commerceContext, async() =>
{
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.PipelineContextOptions;
composerTemplates = await this._getComposerTemplatesPipeline.Run(getComposerTemplatesArgument, pipelineContextOptions).ConfigureAwait(false);
}).ConfigureAwait(false);
return(composerTemplates);
}
}
public virtual async Task <bool> Process(CommerceContext commerceContext, string orderId)
{
// Run the pipeline
using (CommandActivity.Start(commerceContext, this))
{
bool result = false;
await PerformTransaction(commerceContext, (async() =>
{
var requestPaymentArgument = new RequestPaymentArgument(orderId);
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
result = await requestPaymentPipeline.Run(requestPaymentArgument, pipelineContextOptions).ConfigureAwait(false);
}));
return(result);
}
}
/// <summary>
/// Process UpdateCartLineGiftBoxCommand commerce command.
/// </summary>
/// <param name="commerceContext">Commerce context.</param>
/// <param name="cartId">Cart Id.</param>
/// <param name="cartLineId">Cart line Id.</param>
/// <param name="isGiftBox">Cart line gift box boolean attribute.</param>
/// <returns></returns>
public async Task <Cart> Process(CommerceContext commerceContext, string cartId, string cartLineId, bool isGiftBox)
{
try
{
Cart cartResult = null;
using (CommandActivity.Start(commerceContext, this))
{
// find Cart entity
var findCartArgument = new FindEntityArgument(typeof(Cart), cartId, false);
var pipelineContext = new CommercePipelineExecutionContextOptions(commerceContext);
cartResult = await _findEntityPipeline.Run(findCartArgument, pipelineContext) as Cart;
var validationErrorCode = commerceContext.GetPolicy <KnownResultCodes>().ValidationError;
if (cartResult == null)
{
await pipelineContext.CommerceContext.AddMessage(validationErrorCode,
"EntityNotFound",
new object[] { cartId },
$"Cart {cartId} was not found.");
}
else if (!cartResult.Lines.Any(l => l.Id == cartLineId))
{
await pipelineContext.CommerceContext.AddMessage(validationErrorCode,
"CartLineNotFound",
new object[] { cartLineId },
$"Cart line {cartLineId} was not found.");
}
else
{
var arg = new CartLineGiftBoxArgument(cartResult, cartLineId, isGiftBox);
cartResult = await _updateCartLineGiftBoxPipeline.Run(arg, pipelineContext);
}
return(cartResult);
}
}
catch (Exception ex)
{
return(await Task.FromException <Cart>(ex));
}
}
protected override async Task <MinionRunResultsModel> Execute()
{
Condition.Requires(waitingForPaymentOrdersMinionPipeline).IsNotNull($"Not able to resolve the pipeline: IPaymentResultsMinionPipeline");
int totalProcessedItem = 0;
foreach (var listName in Policy.ListsToWatch)
{
var argument = await this.GetListIds <Order>(listName, Policy.ItemsPerBatch);
var list = argument.List;
do
{
foreach (var entityId in argument.EntityReferences.Select(x => x.EntityId))
{
var options = new CommercePipelineExecutionContextOptions(MinionContext);
var result = await waitingForPaymentOrdersMinionPipeline.RunAsync(new WaitingForPaymentOrdersMinionArgument()
{
EntityId = entityId
}, options);
if (result)
{
totalProcessedItem++;
}
else
{
//TODO: Log error
}
}
argument = await this.GetListIds <Order>(listName, Policy.ItemsPerBatch, list.CurrentPage *Policy.ItemsPerBatch);
list = argument.List;
} while (list.CurrentPage < list.PageCount);
}
return(new MinionRunResultsModel()
{
DidRun = true,
ItemsProcessed = totalProcessedItem
});
}
public override async Task <MinionRunResultsModel> Run()
{
MinionRunResultsModel result = new MinionRunResultsModel();
Logger.LogTrace($"{this.Name}: Invoked.");
var executionContext = new CommercePipelineExecutionContextOptions(
new CommerceContext(
MinionContext.Logger,
MinionContext.TelemetryClient,
(IGetLocalizableMessagePipeline)null)
{
Environment = this.Environment
});
var pipelineResult = await this.MinionPipeline.Run(new CreateCouponsArgument(), executionContext);
return(result);
}
public virtual async Task <bool> Process(CommerceContext commerceContext, Dictionary <string, string> parameters)
{
// Run the pipeline
using (CommandActivity.Start(commerceContext, this))
{
bool result = false;
await PerformTransaction(commerceContext, (async() =>
{
var handleResponseArgument = new HandleResponseArgument(parameters);
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
result = await handleResponsePipeline.Run(handleResponseArgument, pipelineContextOptions).ConfigureAwait(false);
}));
return(result);
}
}
public async Task <CommerceCommand> Process(
CommerceContext commerceContext,
IFormFile importFile,
string mode,
int errorThreshold,
bool publishEntities = true)
{
CommerceCommand commerceCommand;
using (CommandActivity.Start(commerceContext, (CommerceCommand)this))
{
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.PipelineContextOptions;
ImportPriceBooksArgument priceBooksArgument = new ImportPriceBooksArgument(importFile, mode)
{
ErrorThreshold = errorThreshold
};
if (publishEntities)
{
commerceContext.Environment.SetPolicy(new AutoApprovePolicy());
}
ImportResult importResult = await ImportPriceBooksPipeline.Run(priceBooksArgument, pipelineContextOptions);
if (importResult != null)
{
this.Messages.AddRange((IEnumerable <CommandMessage>)importResult.Errors);
this.ResponseCode = importResult.ResultCode;
}
else
{
this.ResponseCode = commerceContext.GetPolicy <KnownResultCodes>().Error;
}
if (publishEntities)
{
commerceContext.Environment.RemovePolicy(typeof(AutoApprovePolicy));
}
commerceCommand = (CommerceCommand)this;
}
return(commerceCommand);
}
public virtual async Task <Customer> Process(
CommerceContext commerceContext,
string customerId,
MembershipSubscriptionComponent membershipSubscription)
{
Customer result = null;
Customer customer;
using (CommandActivity.Start(commerceContext, this))
{
await PerformTransaction(commerceContext, async() =>
{
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.GetPipelineContextOptions();
result = await _pipeline.Run(new CustomerMembershipSubscriptioArgument(customerId, membershipSubscription), pipelineContextOptions);
});
customer = result;
}
return(customer);
}
protected virtual async Task <ProductCompare> GetProductCompareComponent(CommerceContext context, string cartId)
{
if (string.IsNullOrEmpty(cartId))
{
return(null);
}
//add a prefix to the cart id so it won't parse into a guid
cartId += "xxx";
var entityId = cartId.StartsWith(CommerceEntity.IdPrefix <ProductCompare>(), StringComparison.OrdinalIgnoreCase) ? cartId : cartId.ToEntityId <ProductCompare>();
var options = new CommercePipelineExecutionContextOptions(context);
var productCompareComponent = await _getProductComparePipeline.Run(entityId, options);
if (productCompareComponent == null)
{
context.Logger.LogDebug($"Entity {entityId} was not found.");
}
return(productCompareComponent);
}
/// <summary>
/// Gets the Fulfillment fee book.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
protected virtual async Task <FulfillmentFeeBook> GetFulfillmentFeeBook(CommerceContext context, string name)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
var entityPrefix = CommerceEntity.IdPrefix <FulfillmentFeeBook>();
var entityId = name.StartsWith(entityPrefix, StringComparison.OrdinalIgnoreCase) ? name : string.Format("{0}{1}", entityPrefix, name);
var arg = new FindEntityArgument(typeof(FulfillmentFeeBook), entityId, false);
var options = new CommercePipelineExecutionContextOptions(context, null, null, null, null, null);
var FulfillmentFeeBook = await this._findEntityPipeline.Run(arg, options) as FulfillmentFeeBook;
if (FulfillmentFeeBook == null)
{
context.Logger.LogDebug(string.Format("Entity {0} was not found.", name));
}
return(FulfillmentFeeBook);
}
public virtual async Task <RunMinionNowCommand> Process(CommerceContext commerceContext, string minionFullName, string environmentName, IList <Policy> policies)
{
RunMinionNowCommand runMinionNowCommand = this;
using (CommandActivity.Start(commerceContext, (CommerceCommand)runMinionNowCommand))
{
if (policies == null)
{
policies = (IList <Policy>) new List <Policy>();
}
CommerceEnvironment commerceEnvironment = await this._getEnvironment.Process(commerceContext, environmentName) ?? commerceContext.Environment;
CommercePipelineExecutionContextOptions pipelineContextOptions = commerceContext.PipelineContextOptions;
pipelineContextOptions.CommerceContext.Environment = commerceEnvironment;
IRunMinionPipeline runMinionPipeline = this._runMinionPipeline;
RunMinionArgument runMinionArgument = new RunMinionArgument(minionFullName);
runMinionArgument.Policies = policies;
CommercePipelineExecutionContextOptions executionContextOptions = pipelineContextOptions;
int num = await runMinionPipeline.Run(runMinionArgument, (IPipelineExecutionContextOptions)executionContextOptions) ? 1 : 0;
}
return(runMinionNowCommand);
}
public override async Task <MinionRunResultsModel> Run()
{
MinionRunResultsModel runResults = new MinionRunResultsModel();
long listCount = await this.GetListCount(this.Policy.ListToWatch);
this.Logger.LogInformation(string.Format("{0}-Review List {1}: Count:{2}", (object)this.Name, (object)this.Policy.ListToWatch, (object)listCount));
foreach (string id in (await this.GetListIds <Order>(this.Policy.ListToWatch, Convert.ToInt32(listCount))).IdList)
{
this.Logger.LogDebug(string.Format("{0}-Reviewing Pending Order: {1}", (object)this.Name, (object)id), Array.Empty <object>());
var minionPipeline = MinionPipeline;
var ordersMinionArgument = new ExportOrdersMinionArgument(id);
var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null);
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
var order = await minionPipeline.Run(ordersMinionArgument, executionContextOptions);
}
return(runResults);
}
protected override async Task <MinionRunResultsModel> Execute()
{
this.Logger.LogInformation("ImportProduct minion started");
MinionRunResultsModel runResults = new MinionRunResultsModel();
var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null);
commerceContext.Environment = this.Environment;
CommercePipelineExecutionContextOptions executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
try
{
runResults = await _iImportProuctsMinionPipeline.Run(runResults, executionContextOptions);
}
finally
{
runResults.HasMoreItems = false;
runResults.DidRun = true;
}
this.Logger.LogInformation("ImportProduct minion completed");
return(runResults);
}
public override async Task <MinionRunResultsModel> Run()
{
MinionRunResultsModel runResults = new MinionRunResultsModel();
var customers = (await this.GetListItems <Customer>("Customers", 20, 0));
if (customers != null && customers.Any())
{
foreach (var customer in customers)
{
this.Logger.LogDebug(string.Format("{0}-Reviewing Customer: {1}", (object)this.Name, (object)customer.Id), Array.Empty <object>());
var reconcilePointsArgument = new ReconcilePointsArgument(customer.Id);
var commerceContext = new CommerceContext(this.Logger, this.MinionContext.TelemetryClient, (IGetLocalizableMessagePipeline)null);
commerceContext.Environment = this.Environment;
var executionContextOptions = new CommercePipelineExecutionContextOptions(commerceContext, null, null, null, null, null);
var order = await this.ReconcilePointsMinionPipeline.Run(reconcilePointsArgument, executionContextOptions);
}
}
return(runResults);
}
