public virtual async Task <WishList> Process(CommerceContext commerceContext, string wishListId, WishListLineComponent line)
{
WishList result = null;
using (CommandActivity.Start(commerceContext, this))
{
var context = commerceContext.GetPipelineContextOptions();
var findEntityArgument = new FindEntityArgument(typeof(WishList), wishListId);
var wishList = await _getPipeline.Run(findEntityArgument, context) as WishList;
if (wishList == null)
{
await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "EntityNotFound", new object[] { wishListId }, string.Format("Entity {0} was not found.", wishListId));
return(null);
}
if (wishList.Lines.FirstOrDefault <WishListLineComponent>(c => c.Id == line.Id) == null)
{
await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "WishListLineNotFound", new object[] { line.Id }, string.Format("WishList line {0} was not found", line.Id));
return(wishList);
}
result = await _pipeline.Run(new WishListLineArgument(wishList, line), context);
return(result);
}
}
public virtual async Task <WishList> Process(CommerceContext commerceContext, string wishListId, WishListLineComponent line)
{
using (CommandActivity.Start(commerceContext, this))
{
var context = commerceContext.GetPipelineContextOptions();
var findEntityArgument = new FindEntityArgument(typeof(WishList), wishListId, true);
var wishList = await _getPipeline.Run(findEntityArgument, context) as WishList;
if (wishList == null)
{
await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "EntityNotFound", new object[] { wishListId }, string.Format("Entity {0} was not found.", wishListId));
return(null);
}
if (!wishList.IsPersisted)
{
wishList.Id = wishListId;
wishList.Name = wishListId;
wishList.ShopName = commerceContext.CurrentShopName();
}
var result = await _addToWishListPipeline.Run(new WishListLineArgument(wishList, line), context);
await _persistEntityPipeline.Run(new PersistEntityArgument(result), context);
return(result);
}
}
public override async Task <Cart> Run(Cart arg, CommercePipelineExecutionContext context)
{
Condition.Requires <Cart>(arg).IsNotNull <Cart>(string.Format("{0}: the cart can not be null.", (object)this.Name));
if (arg.HasComponent <TemporaryCartComponent>())
{
return(arg);
}
AddToCartKitsBlock addKitsBlock = this;
context.CommerceContext.AddObject((object)arg);
Cart cart = arg;
FindEntityArgument getSavedCartArg = new FindEntityArgument(typeof(Cart), arg.Id, false);
Cart savedCart = await this._findEntityPipeline.Run(getSavedCartArg, (CommercePipelineExecutionContext)context).ConfigureAwait(false) as Cart;
CartLineComponent existingLine;
if (savedCart == null)
{
existingLine = arg.Lines.FirstOrDefault <CartLineComponent>();
}
else
{
var savedCartLines = savedCart.Lines;
var currentCartLines = cart.Lines;
var addedCartLine = cart.Lines.Where(l => savedCartLines.Where(sc => sc.Id == l.Id).FirstOrDefault() == null).FirstOrDefault();
existingLine = addedCartLine;
}
if (existingLine != null)
{
//var cartLineProductComponent = existingLine.GetComponent<CartProductComponent>();
//bool hasTag = cartLineProductComponent.Tags.Any<Tag>((Func<Tag, bool>)(t => t.Name.Equals("kit", StringComparison.OrdinalIgnoreCase)));
FindEntityArgument getProductArg = new FindEntityArgument(typeof(SellableItem), "Entity-SellableItem-" + (existingLine.ItemId.Split('|').Count() > 1 ? existingLine.ItemId.Split('|')[1] : existingLine.ItemId), false);
SellableItem carLineProduct = await this._findEntityPipeline.Run(getProductArg, (CommercePipelineExecutionContext)context).ConfigureAwait(false) as SellableItem;
bool hasTag = carLineProduct.Tags.Any <Tag>((Func <Tag, bool>)(t => t.Name.Equals("kit", StringComparison.OrdinalIgnoreCase)));
if (hasTag)
{
string listId = String.Format("relatedproduct-{0}", existingLine.ItemId.Split('|').Count() > 1 ? existingLine.ItemId.Split('|')[1] : existingLine.ItemId);
var relatedProducts = await _findEntitiesInListPipeline.Run(
new FindEntitiesInListArgument(typeof(CommerceEntity), listId, 0, 10)
{
LoadEntities = true
},
context);
foreach (var relProd in relatedProducts.List.Items)
{
existingLine.Comments += relProd.Id + ',' + relProd.DisplayName + '|';
}
}
}
return(cart);
}
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 <AddReviewArgument> Run(AddReviewArgument args, CommercePipelineExecutionContext context)
{
InsureSellableItemBlock insureSellableItemBlock = this;
Condition.Requires(args).IsNotNull($"{insureSellableItemBlock.Name}: The block argument cannot be null.");
FindEntityArgument findEntityArgument = new FindEntityArgument(typeof(SellableItem), args.ProductId.EnsurePrefix(CommerceEntity.IdPrefix <SellableItem>()), false);
SellableItem productItem = await insureSellableItemBlock.findEntityPipeline.Run(findEntityArgument, context) as SellableItem;
args.Product = productItem;
return(args);
}
public virtual async Task <Cart> Process(CommerceContext commerceContext, string wishlistId, CartLineComponent line)
{
AddWishListLineItemCommand addCartLineCommand = this;
Cart result = (Cart)null;
using (CommandActivity.Start(commerceContext, (CommerceCommand)addCartLineCommand))
{
await addCartLineCommand.PerformTransaction(commerceContext, (Func <Task>)(async() =>
{
FindEntityArgument findEntityArgument = new FindEntityArgument(typeof(Cart), wishlistId, true);
var context = commerceContext.GetPipelineContextOptions();
Cart cart = await this._getPipeline.Run(findEntityArgument, (IPipelineExecutionContextOptions)commerceContext.GetPipelineContextOptions()).ConfigureAwait(false) as Cart;
if (cart == null)
{
string str = await context.CommerceContext.AddMessage(commerceContext.GetPolicy <KnownResultCodes>().ValidationError, "EntityNotFound", new object[1]
{
(object)wishlistId
}, string.Format("Entity {0} was not found.", (object)wishlistId));
}
else
{
if (!cart.IsPersisted)
{
cart.Id = wishlistId;
cart.Name = wishlistId;
cart.ShopName = commerceContext.CurrentShopName();
cart.SetComponent((Component) new ListMembershipsComponent()
{
Memberships = (IList <string>) new List <string>()
{
CommerceEntity.ListName <Cart>()
}
});
cart.SetComponent(new CartTypeComponent()
{
CartType = CartTypeEnum.Wishlist.ToString()
});
}
result = await this._addWishListLineItemPipeli.Run(new CartLineArgument(cart, line), (IPipelineExecutionContextOptions)context);
}
}));
}
return(result);
}
/// <summary>Executes the pipeline block's code logic.</summary>
/// <param name="arg">The pipeline argument.</param>
/// <param name="context">The context.</param>
/// <returns>The <see cref="EntityView"/>.</returns>
public override async Task <EntityView> RunAsync(EntityView arg, CommercePipelineExecutionContext context)
{
if (string.IsNullOrEmpty(arg?.Action) ||
!arg.Action.Equals(context.GetPolicy <KnownEntityVersionsActionsPolicy>().AddEntityVersion, StringComparison.OrdinalIgnoreCase))
{
return(arg);
}
var commerceEntity = context.CommerceContext.GetObjects <CommerceEntity>().FirstOrDefault(p => p.Id.Equals(arg.EntityId, StringComparison.OrdinalIgnoreCase));
if (commerceEntity == null)
{
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().ValidationError,
"EntityNotFound",
new object[]
{
arg.EntityId
},
$"Entity {arg.EntityId} was not found.")
.ConfigureAwait(false);
return(arg);
}
var findArg = new FindEntityArgument(typeof(VersioningEntity), VersioningEntity.GetIdBasedOnEntityId(commerceEntity.Id));
var versions = await _commerceCommander.Pipeline <IFindEntityPipeline>()
.RunAsync(findArg, context)
.ConfigureAwait(false);
var latestVersion = (versions as VersioningEntity)?.LatestVersion(context.CommerceContext) ?? 1;
var newVersion = latestVersion + 1;
await _commerceCommander.ProcessWithTransaction(context.CommerceContext,
() => _commerceCommander.Pipeline <IAddEntityVersionPipeline>()
.RunAsync(new AddEntityVersionArgument(commerceEntity)
{
CurrentVersion = commerceEntity.EntityVersion,
NewVersion = newVersion
},
context.CommerceContext.PipelineContextOptions)).ConfigureAwait(false);
context.CommerceContext.AddModel(
new RedirectUrlModel($"/entityView/Master/{newVersion}/{arg.EntityId}")
);
return(arg);
}
public override Task <OrderNumberEntity> RunAsync(GenerateOrderNumberArgument arg, CommercePipelineExecutionContext context)
{
var orderNumberPolicy = context.GetPolicy <OrderNumberPolicy>();
var shopName = context.CommerceContext.CurrentShopName();
if (string.IsNullOrEmpty(shopName))
{
shopName = DefaultOrderNumberLockKey;
}
var lockObject = LockTable.GetOrAdd(shopName, x => new object());
lock (lockObject)
{
Condition.Requires(_findEntityPipeline, "findEntitiesPipeline");
var findEntityArgument = new FindEntityArgument(typeof(OrderNumberEntity), OrderNumberEntity.OrderNumberEntityId);
var foundEntity = _findEntityPipeline.RunAsync(findEntityArgument, context).Result;
var result = foundEntity as OrderNumberEntity;
if (result == null)
{
result = new OrderNumberEntity()
{
UniqueId = Guid.NewGuid(),
Id = OrderNumberEntity.OrderNumberEntityId,
Version = 1,
LastOrderNumber = orderNumberPolicy?.StartNumber ?? 1,
DateCreated = DateTimeOffset.Now
};
}
else
{
result.LastOrderNumber += 1;
result.DateUpdated = DateTimeOffset.Now;
}
var persistEntity = _persistEntityPipeline.RunAsync(new PersistEntityArgument(result), context).Result;
return(Task.FromResult(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));
}
}
public async Task <IEnumerable <T> > Process <T>(CommerceContext commerceContext, IEnumerable <T> items) where T : CommerceEntity
{
using (CommandActivity.Start(commerceContext, this))
{
var returnedItems = new List <T>();
foreach (var item in items)
{
var findEntityArgument = new FindEntityArgument(typeof(T), item.Id, false);
var commerceEntity = await Pipeline <IFindEntityPipeline>().Run(findEntityArgument, commerceContext.PipelineContextOptions);
if (commerceEntity != null)
{
returnedItems.Add(commerceEntity as T);
}
}
return(returnedItems);
}
}
public override async Task <CartLineArgument> Run(CartLineArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires <CartLineArgument>(arg).IsNotNull <CartLineArgument>("The argument can not be null");
Condition.Requires <Cart>(arg.Cart).IsNotNull <Cart>("The cart can not be null");
Condition.Requires <CartLineComponent>(arg.Line).IsNotNull <CartLineComponent>("The lines can not be null");
Cart cart = arg.Cart;
List <CartLineComponent> lines = cart.Lines.ToList <CartLineComponent>();
CartLineComponent existingLine = lines.FirstOrDefault <CartLineComponent>((Func <CartLineComponent, bool>)(l => l.Id.Equals(arg.Line.Id, StringComparison.OrdinalIgnoreCase)));
if (existingLine != null)
{
FindEntityArgument getProductArg = new FindEntityArgument(typeof(SellableItem), "Entity-SellableItem-" + (existingLine.ItemId.Split('|').Count() > 1 ? existingLine.ItemId.Split('|')[1] : existingLine.ItemId), false);
SellableItem carLineProduct = await this._findEntityPipeline.Run(getProductArg, (CommercePipelineExecutionContext)context).ConfigureAwait(false) as SellableItem;
bool hasTag = carLineProduct.Tags.Any <Tag>((Func <Tag, bool>)(t => t.Name.Equals("bundle", StringComparison.OrdinalIgnoreCase)));
if (hasTag)
{
string listId = String.Format("relatedproduct-{0}", existingLine.ItemId.Split('|').Count() > 1 ? existingLine.ItemId.Split('|')[1] : existingLine.ItemId);
var relatedProducts = await _findEntitiesInListPipeline.Run(
new FindEntitiesInListArgument(typeof(CommerceEntity), listId, 0, 10)
{
LoadEntities = true
},
context);
foreach (var relProd in relatedProducts.List.Items)
{
if (cart.Lines.Any(l => l.ItemId.Contains(relProd.FriendlyId)))
{
var relatedProductCartLine = cart.Lines.FirstOrDefault <CartLineComponent>(l => l.ItemId.Contains(relProd.FriendlyId));
if (relatedProductCartLine != null)
{
cart.Lines.Remove(relatedProductCartLine);
}
}
}
}
}
return(arg);
}
/// <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 async Task <IEnumerable <InventoryInformation> > Process(CommerceContext commerceContext, IEnumerable <InventoryInformation> items)
{
using (CommandActivity.Start(commerceContext, this))
{
var returnedItems = new List <InventoryInformation>();
foreach (var item in items)
{
var findEntityArgument = new FindEntityArgument(typeof(InventoryInformation), item.Id, false);
// No bulk API exists in core platform, under the hood it's reading one at a time.
// I've layed out the import in this manner so you can test how long each piece takes
// An option you have is to do a select directly against the DB, for all items in this batch
// to see if you need to make this call.
if (await Pipeline <IFindEntityPipeline>().Run(findEntityArgument, commerceContext.PipelineContextOptions) is InventoryInformation commerceEntity)
{
returnedItems.Add(commerceEntity);
}
}
return(returnedItems);
}
}
/// <summary>
/// Runs the specified argument.
/// </summary>
/// <param name="arg">The argument.</param>
/// <param name="context">The context.</param>
/// <returns>A string</returns>
public override async Task <FindEntityArgument> Run(FindEntityArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The FindEntityArgument argument cannot be null or empty.");
if (arg.EntityType != typeof(CommerceEnvironment))
{
return(arg);
}
try
{
if (arg.SerializedEntity != null)
{
arg.SerializedEntity = await this.MigrateEntity(arg.SerializedEntity, context.CommerceContext);
}
return(arg);
}
catch (Exception ex)
{
context.CommerceContext.LogException(this.Name, ex);
throw;
}
}
/// <summary>
/// Processes the specified commerce context.
/// </summary>
/// <param name="commerceContext">The commerce context.</param>
/// <param name="sourceEnvironmentName">Name of the source environment.</param>
/// <param name="newEnvironmentName">New name of the environment.</param>
/// <param name="newArtifactStoreId">The new artifact store identifier.</param>
/// <returns>
/// User site terms
/// </returns>
public virtual async Task <bool> Process(CommerceContext commerceContext, string sourceEnvironmentName, string newEnvironmentName, Guid newArtifactStoreId)
{
using (CommandActivity.Start(commerceContext, this))
{
var migrationSqlPolicy = commerceContext.GetPolicy <MigrationSqlPolicy>();
if (migrationSqlPolicy == null)
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "MigrationSqlPolicy" },
$"{this.GetType()}. Missing MigrationSqlPolicy");
return(false);
}
if (string.IsNullOrEmpty(migrationSqlPolicy.SourceStoreSqlPolicy.Server))
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "MigrationSqlPolicy" },
$"{this.GetType()}. Empty server name in the MigrationSqlPolicy");
return(false);
}
var migrationPolicy = commerceContext.GetPolicy <MigrationPolicy>();
if (migrationPolicy == null)
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "MigrationPolicy" },
$"{this.GetType()}. Missing MigrationPolicy");
return(false);
}
Guid id;
if (!Guid.TryParse(migrationSqlPolicy.ArtifactStoreId, out id))
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "MigrationSqlPolicy.ArtifactStoreId" },
"MigrationSqlPolicy. Invalid ArtifactStoreId");
return(false);
}
var context = commerceContext.GetPipelineContextOptions();
var findArg = new FindEntityArgument(typeof(CommerceEnvironment), $"{CommerceEntity.IdPrefix<CommerceEnvironment>()}{newEnvironmentName}");
var findResult = await this._findEntityPipeline.Run(findArg, context);
var newEnvironment = findResult as CommerceEnvironment;
if (newEnvironment != null)
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { newEnvironmentName },
$"Environment {newEnvironmentName} already exists.");
return(false);
}
findArg = new FindEntityArgument(typeof(CommerceEnvironment), $"{CommerceEntity.IdPrefix<CommerceEnvironment>()}{migrationPolicy.DefaultEnvironmentName}");
findResult = await this._findEntityPipeline.Run(findArg, context);
var sourceEnvironment = findResult as CommerceEnvironment;
if (sourceEnvironment == null)
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"EntityNotFound",
new object[] { migrationPolicy.DefaultEnvironmentName },
$"Entity {migrationPolicy.DefaultEnvironmentName} was not found.");
return(false);
}
if (sourceEnvironment.HasPolicy <EntityShardingPolicy>())
{
commerceContext.AddUniqueObjectByType(sourceEnvironment.GetPolicy <EntityShardingPolicy>());
sourceEnvironment.RemovePolicy(typeof(EntityShardingPolicy));
}
// set sql policies
var sqlPoliciesCollection = new List <KeyValuePair <string, EntityStoreSqlPolicy> >
{
new KeyValuePair <string, EntityStoreSqlPolicy>("SourceGlobal", migrationSqlPolicy.SourceStoreSqlPolicy)
};
// Get sql Policy set
var ps = await this._findEntityPipeline.Run(new FindEntityArgument(typeof(PolicySet), $"{CommerceEntity.IdPrefix<PolicySet>()}{migrationPolicy.SqlPolicySetName}"), context);
if (ps == null)
{
context.CommerceContext.Logger.LogError($"PolicySet {migrationPolicy.SqlPolicySetName} was not found.");
}
else
{
sqlPoliciesCollection.Add(new KeyValuePair <string, EntityStoreSqlPolicy>("DestinationShared", ps.GetPolicy <EntityStoreSqlPolicy>()));
}
commerceContext.AddUniqueObjectByType(sqlPoliciesCollection);
sourceEnvironment.Name = sourceEnvironmentName;
sourceEnvironment.ArtifactStoreId = id;
sourceEnvironment.Id = $"{CommerceEntity.IdPrefix<CommerceEnvironment>()}{sourceEnvironmentName}";
sourceEnvironment.SetPolicy(migrationSqlPolicy.SourceStoreSqlPolicy);
var migrateEnvironmentArgument = new MigrateEnvironmentArgument(sourceEnvironment, newArtifactStoreId, newEnvironmentName);
var result = await this._migrateEnvironmentPipeline.Run(migrateEnvironmentArgument, context);
return(result);
}
}
