public bool Evaluate(IRuleExecutionContext context)
{
var commerceContext = context.Fact <CommerceContext>(null);
var cart = commerceContext?.GetObject <Cart>();
var optionName = FulfillmentOptionName.Yield(context);
if (cart == null || !cart.Lines.Any() || (!cart.HasComponent <FulfillmentComponent>() || string.IsNullOrEmpty(optionName)))
{
return(false);
}
var fulfillment = cart.GetComponent <FulfillmentComponent>();
if (string.IsNullOrEmpty(fulfillment.FulfillmentMethod?.EntityTarget) || string.IsNullOrEmpty(fulfillment.FulfillmentMethod?.Name))
{
return(false);
}
var methods = Task.Run(() => Commander.Command <GetFulfillmentMethodsCommand>().Process(commerceContext)).Result;
var optionMethods = methods.Where(o => o.FulfillmentType.Equals(optionName, StringComparison.OrdinalIgnoreCase)).ToList();
var hasMethod = optionMethods.Any(m =>
{
if (m.Id.Equals(fulfillment.FulfillmentMethod.EntityTarget, StringComparison.OrdinalIgnoreCase))
{
return(m.Name.Equals(fulfillment.FulfillmentMethod.Name, StringComparison.OrdinalIgnoreCase));
}
return(false);
});
return(hasMethod);
}
public int GetInt(IRuleExecutionContext requestInfo, IRuleResult ruleResult, int defaultValue)
{
var value = GetString(requestInfo, ruleResult);
int intValue;
return(int.TryParse(value, out intValue) ? intValue : defaultValue);
}
public bool Evaluate(IRuleExecutionContext context)
{
var commerceContext = context.Fact <CommerceContext>();
//Get configuration
string specificCategory = Hc_SpecificCategory.Yield(context);
decimal specificValue = Hc_SpecificValue.Yield(context);
bool includeSubCategories = Hc_IncludeSubCategories.Yield(context);
if (string.IsNullOrEmpty(specificCategory) || specificValue == 0 || Hc_Compares == null)
{
return(false);
}
//Get data
IEnumerable <CartLineComponent> categoryLines =
categoryCartLinesResolver.Resolve(commerceContext, specificCategory, includeSubCategories);
if (categoryLines == null)
{
return(false);
}
//Validate data against configuration
decimal categoryTotal = categoryLines.Sum(line => line.Totals.GrandTotal.Amount);
return(Hc_Compares.Evaluate(categoryTotal, specificValue));
}
public void Execute_02_NoCart(
IRuleValue <string> targetTag,
CartTotals cartTotals,
CommerceContext commerceContext,
CartItemTargetTagFreeGiftAction action,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
commerceContext.AddObject(cartTotals);
action.TargetTag = targetTag;
context.Fact(Arg.Any <IFactIdentifier>()).Returns(commerceContext);
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
}
public bool Evaluate(IRuleExecutionContext context)
{
Contact contact = context.Fact <Contact>();
if (Comparison == NumericOperationType.IsNotEqualTo)
{
if (contact.ContactBehaviorProfile()?.Scores != null)
{
return(contact.ContactBehaviorProfile().Scores.All(y =>
{
if (!(y.Value.ProfileDefinitionId != ProfileDefinitionId) && y.Value.Values.ContainsKey(ProfileKeyDefinitionId))
{
return y.Value.Values[ProfileKeyDefinitionId] != Number;
}
return true;
}));
}
return(true);
}
if (contact.ContactBehaviorProfile()?.Scores == null)
{
return(false);
}
return(contact.ContactBehaviorProfile().Scores.Any(y =>
{
if (y.Value.ProfileDefinitionId == ProfileDefinitionId && y.Value.Values.ContainsKey(ProfileKeyDefinitionId))
{
return Comparison.Evaluate(y.Value.Values[ProfileKeyDefinitionId], Number);
}
return false;
}));
}
public void Execute_03_NoCartLines(
CartShippingOptionAmountOffAction action,
IRuleValue <string> fulfillmentOptionName,
IRuleValue <decimal> amountOff,
Cart cart,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.Clear();
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cart);
action.FulfillmentOptionName = fulfillmentOptionName;
action.AmountOff = amountOff;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
public void Execute_01_NoCommerceContext(
CartItemQuantityRangePercentOffAction action,
IRuleValue <string> targetItemId,
IRuleValue <decimal> minQuantity,
IRuleValue <decimal> maxQuantity,
IRuleValue <decimal> percentOff,
Cart cart,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.ForEach(l => l.Adjustments.Clear());
context.Fact <CommerceContext>().ReturnsForAnyArgs((CommerceContext)null);
action.TargetItemId = targetItemId;
action.MinQuantity = minQuantity;
action.MaxQuantity = maxQuantity;
action.PercentOff = percentOff;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
public void Execute_12_NoFulfillmentFee(
IRuleValue <string> fulfillmentOptionName,
IRuleValue <decimal> amountOff,
Cart cart,
CommerceContext commerceContext,
IRuleExecutionContext context,
string fulfillmentOptionNameValue,
FulfillmentComponent fulfillmentComponent)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.ForEach(l => l.Adjustments.Clear());
cart.SetComponent(fulfillmentComponent);
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cart);
fulfillmentOptionName.Yield(context).ReturnsForAnyArgs(fulfillmentOptionNameValue);
amountOff.Yield(context).ReturnsForAnyArgs(MINIMUM_AMOUNT_OFF);
var commander = Substitute.For <CommerceCommander>(Substitute.For <IServiceProvider>());
var command = Substitute.For <GetFulfillmentMethodsCommand>(
Substitute.For <IFindEntityPipeline>(),
Substitute.For <IGetCartFulfillmentMethodsPipeline>(),
Substitute.For <IGetCartLineFulfillmentMethodsPipeline>(),
Substitute.For <IGetFulfillmentMethodsPipeline>(),
Substitute.For <IServiceProvider>());
var fulfillmentMethod = new FulfillmentMethod()
{
FulfillmentType = fulfillmentOptionNameValue
};
command.Process(commerceContext).ReturnsForAnyArgs(new List <FulfillmentMethod>()
{
fulfillmentMethod
}.AsEnumerable());
commander.When(x => x.Command <GetFulfillmentMethodsCommand>()).DoNotCallBase();
commander.Command <GetFulfillmentMethodsCommand>().Returns(command);
var action = new CartShippingOptionAmountOffAction(commander)
{
FulfillmentOptionName = fulfillmentOptionName,
AmountOff = amountOff
};
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
command.Received().Process(commerceContext);
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
public void Execute_08_NoAmount(
BaseCartItemSubtotalAmountOffAction action,
IBinaryOperator <decimal, decimal> subtotalOperator,
IRuleValue <decimal> subtotal,
Cart cart,
CartTotals cartTotals,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.ForEach(l => l.Adjustments.Clear());
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cartTotals);
commerceContext.AddObject(cart);
action.MatchingLines(context).ReturnsForAnyArgs(cart.Lines);
action.SubtotalOperator = subtotalOperator;
action.Subtotal = subtotal;
action.AmountOff = null;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
public void Execute_ShouldRoundPriceCalc_True(
BaseCartItemSubtotalAmountOffAction action,
IRuleValue <decimal> subtotal,
IRuleValue <decimal> amountOff,
Cart cart,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.ForEach(l => l.Adjustments.Clear());
var globalPricingPolicy = commerceContext.GetPolicy <GlobalPricingPolicy>();
globalPricingPolicy.ShouldRoundPriceCalc = true;
globalPricingPolicy.RoundDigits = 3;
globalPricingPolicy.MidPointRoundUp = true;
cart.Lines.ForEach(l => l.Totals.SubTotal.Amount = 100);
var cartline = cart.Lines[1];
cartline.Totals.SubTotal.Amount = 175;
var cartTotals = new CartTotals(cart);
subtotal.Yield(context).ReturnsForAnyArgs(150);
amountOff.Yield(context).ReturnsForAnyArgs(25.555555M);
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cartTotals);
commerceContext.AddObject(cart);
action.MatchingLines(context).ReturnsForAnyArgs(cart.Lines);
action.SubtotalOperator = new DecimalGreaterThanEqualToOperator();
action.Subtotal = subtotal;
action.AmountOff = amountOff;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().HaveCount(1);
cart.Adjustments.Should().BeEmpty();
cartTotals.Lines[cartline.Id].SubTotal.Amount.Should().Be(149.444M);
cartline.Adjustments.Should().NotBeEmpty();
cartline.Adjustments.FirstOrDefault().Should().NotBeNull();
cartline.Adjustments.FirstOrDefault().Should().BeOfType <CartLineLevelAwardedAdjustment>();
cartline.Adjustments.FirstOrDefault()?.Name.Should().Be(commerceContext.GetPolicy <KnownCartAdjustmentTypesPolicy>().Discount);
cartline.Adjustments.FirstOrDefault()?.DisplayName.Should().Be(commerceContext.GetPolicy <KnownCartAdjustmentTypesPolicy>().Discount);
cartline.Adjustments.FirstOrDefault()?.AdjustmentType.Should().Be(commerceContext.GetPolicy <KnownCartAdjustmentTypesPolicy>().Discount);
cartline.Adjustments.FirstOrDefault()?.AwardingBlock.Should().Contain(nameof(BaseCartItemSubtotalAmountOffAction));
cartline.Adjustments.FirstOrDefault()?.IsTaxable.Should().BeFalse();
cartline.Adjustments.FirstOrDefault()?.Adjustment.CurrencyCode.Should().Be(commerceContext.CurrentCurrency());
cartline.Adjustments.FirstOrDefault()?.Adjustment.Amount.Should().Be(-25.556M);
cartline.HasComponent <MessagesComponent>().Should().BeTrue();
}
public bool Evaluate(IRuleExecutionContext context)
{
//Get configuration
string specificCategory = Hc_SpecificCategory.Yield(context);
decimal specificValue = Hc_SpecificValue.Yield(context);
bool includeSubCategories = Hc_IncludeSubCategories.Yield(context);
if (string.IsNullOrEmpty(specificCategory) || specificValue == 0 || Hc_Compares == null)
{
return(false);
}
//Get Data
var commerceContext = context.Fact <CommerceContext>();
List <CartLineComponent> categoryLines = AsyncHelper.RunSync(() =>
categoryOrderLinesResolver.Resolve(commerceContext, specificCategory, includeSubCategories));
if (categoryLines == null)
{
return(false);
}
//Validate data against configuration
decimal productAmount = categoryLines.Sum(x => x.Quantity);
return(Hc_Compares.Evaluate(productAmount, specificValue));
}
public void Execute_13_NoMaximumApplications(
CartAnyItemQuantityXForQuantityYAction action,
IRuleValue <int> quantityX,
IRuleValue <int> quantityY,
//IRuleValue<int> maximumApplications,
Cart cart,
CartTotals cartTotals,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.ForEach(l => l.Adjustments.Clear());
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cartTotals);
commerceContext.AddObject(cart);
action.QuantityX = quantityX;
action.QuantityY = quantityY;
action.MaximumApplications = null;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().Throw <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
public bool Evaluate(IRuleExecutionContext context)
{
Contact contact = context.Fact <Contact>();
var scores = contact.ContactBehaviorProfile()?.Scores;
if (scores != null)
{
return(scores.Any(y =>
{
if (!(y.Value.ProfileDefinitionId == ProfileDefinitionId))
{
return false;
}
Guid?matchedPatternId1 = y.Value.MatchedPatternId;
Guid matchedPatternId2 = MatchedPatternId;
if (!matchedPatternId1.HasValue)
{
return false;
}
return matchedPatternId1.GetValueOrDefault() == matchedPatternId2;
}));
}
return(true);
}
public void Evaluate_05_NoFulfillmentOptionName(
CommerceContext commerceContext,
Cart cart,
IRuleExecutionContext context,
FulfillmentComponent fulfillmentComponent)
{
/**********************************************
* Arrange
**********************************************/
cart.SetComponent(fulfillmentComponent);
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cart);
var commander = Substitute.For <CommerceCommander>(Substitute.For <IServiceProvider>());
var condition = new CartHasFulfillmentOptionCondition(commander);
condition.FulfillmentOptionName = null;
/**********************************************
* Act
**********************************************/
Action evaluateCondition = () => condition.Evaluate(context);
/**********************************************
* Assert
**********************************************/
evaluateCondition.Should().Throw <Exception>();
}
// Evaluates condition for single contact
public bool Evaluate(IRuleExecutionContext context)
{
var contact = context.Fact <Contact>();
EmailAddressList emails = CollectionModel.Emails(RuleExecutionContextExtensions.Fact <Contact>(context, null));
return(emails?.PreferredEmail == null ? false : emails.PreferredEmail.Validated);
}
public bool Evaluate(IRuleExecutionContext context)
{
//itemId = ID to check in purchase order history
//itemInCartItemId = Item in cart to check in order history to give discount
//If customer has purchased itemId and has not purchased itemInCartItemId this rule returns true
string itemId = this.TargetItemId.Yield(context);
string itemInCartItemId = this.CurrentItemInCartId.Yield(context);
bool valid = false;
CommerceContext commerceContext = context.Fact <CommerceContext>((string)null);
if (commerceContext == null || !commerceContext.CurrentUserIsRegistered() || string.IsNullOrEmpty(itemId))
{
return(false);
}
//UPDATED TO USE CURRENTSHOPPERID VS EMPTY CURRENTCUSTOMERID
string listName = string.Format(commerceContext.GetPolicy <KnownOrderListsPolicy>().CustomerOrders, (object)commerceContext.CurrentShopperId());
CommerceList <Order> result = Task.Run <CommerceList <Order> >((Func <Task <CommerceList <Order> > >)(() => this._getEntitFindEntitiesInListCommand.Process <Order>(commerceContext, listName, 0, int.MaxValue))).Result;
List <Order> source = result != null?result.Items.ToList <Order>() : (List <Order>)null;
if (source == null || !source.Any <Order>())
{
return(false);
}
if (!this.MatchesAnItem(context))
{
if (
source.Any <Order>(
(Func <Order, bool>)(
o => o.Lines.Any <CartLineComponent>(
(Func <CartLineComponent, bool>)(
l => l.ItemId.StartsWith(itemId, StringComparison.OrdinalIgnoreCase)
)))))
{
valid = source.Where <Order>(
(Func <Order, bool>)(
o => o.Lines.Where <CartLineComponent>(
(Func <CartLineComponent, bool>)(
l => l.ItemId.Contains(itemInCartItemId)
)).FirstOrDefault() != null)).FirstOrDefault() == null;
return(valid);
}
}
if (source.Any <Order>(
(Func <Order, bool>)(
o => o.Lines.Any <CartLineComponent>(
(Func <CartLineComponent, bool>)(
l => l.ItemId.Equals(itemId)
)))))
{
valid = source.Where <Order>(
(Func <Order, bool>)(
o => o.Lines.Where <CartLineComponent>(
(Func <CartLineComponent, bool>)(
l => !l.ItemId.Equals(itemInCartItemId, StringComparison.OrdinalIgnoreCase)
)).FirstOrDefault() == null)).FirstOrDefault() == null;
return(valid);
}
return(valid);
}
public bool Evaluate(IRuleExecutionContext context)
{
var contact = RuleExecutionContextExtensions.Fact <Contact>(context);
XConnectClient client = XConnectClientReference.GetClient();
Contact existingContact = client.Get <Contact>(contact, new ContactExpandOptions(CvPersonFacet.DefaultFacetKey));
CvPersonFacet personFacet = existingContact.GetFacet <CvPersonFacet>(CvPersonFacet.DefaultFacetKey);
if (string.IsNullOrEmpty(personFacet?.Company))
{
return(false);
}
//string[] partnersList = Partners.Split(';');
//bool result = partnersList.Any(p => p.IndexOf(personFacet.Company, StringComparison.OrdinalIgnoreCase) > 0);
bool result = Partners.IndexOf(personFacet.Company, StringComparison.OrdinalIgnoreCase) > 0;
Log.Information("PartnerListMatches result == " + (result).ToString());
return(result);
}
public bool Evaluate(IRuleExecutionContext context)
{
//Get configuration
string specificFulfillment = Ny_SpecificFulfillment.Yield(context);
string basicStringCompare = Ny_BasicStringCompare.Yield(context);
if (string.IsNullOrEmpty(specificFulfillment) || string.IsNullOrEmpty(basicStringCompare))
{
return(false);
}
//Get Data
var cart = context.Fact <CommerceContext>()?.GetObject <Cart>();
if (cart == null || !cart.Lines.Any() || !cart.HasComponent <FulfillmentComponent>())
{
return(false);
}
var fulfillment = cart.GetComponent <FulfillmentComponent>();
if (fulfillment == null)
{
return(false);
}
//Validate data against configuration
string selectedFulfillment = fulfillment.FulfillmentMethod.Name;
return(BasicStringComparer.Evaluate(basicStringCompare, selectedFulfillment, specificFulfillment));
}
public void Execute_02_NoCart(
CartItemQuantityRangePercentOffAction action,
IRuleValue <string> targetItemId,
IRuleValue <decimal> minQuantity,
IRuleValue <decimal> maxQuantity,
IRuleValue <decimal> percentOff,
CartTotals cartTotals,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cartTotals);
action.TargetItemId = targetItemId;
action.MinQuantity = minQuantity;
action.MaxQuantity = maxQuantity;
action.PercentOff = percentOff;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
}
public void YieldCartLines_08_Multiple(
IRuleValue <string> targetBrand,
Cart cart,
LineItemProductExtendedComponent component,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
component.Brand = "Smartphone";
cart.Lines.ForEach(l => l.SetComponent(component));
commerceContext.AddObject(cart);
targetBrand.Yield(context).ReturnsForAnyArgs("Smartphone");
/**********************************************
* Act
**********************************************/
var matchingLines = targetBrand.YieldCartLinesWithBrand(context);
/**********************************************
* Assert
**********************************************/
matchingLines.Should().HaveCount(3);
}
public void Evaluate_03_NoCartLines(
IRuleValue <string> fulfillmentOptionName,
CommerceContext commerceContext,
Cart cart,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Lines.Clear();
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cart);
var commander = Substitute.For <CommerceCommander>(Substitute.For <IServiceProvider>());
var condition = new CartHasFulfillmentOptionCondition(commander);
condition.FulfillmentOptionName = fulfillmentOptionName;
/**********************************************
* Act
**********************************************/
var result = condition.Evaluate(context);
/**********************************************
* Assert
**********************************************/
result.Should().BeFalse();
}
public void YieldCartLines_04_NoLineItemComponent(
IRuleValue <string> targetBrand,
Cart cart,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cart);
targetBrand.Yield(context).ReturnsForAnyArgs("Smartphone");
/**********************************************
* Act
**********************************************/
IEnumerable <CartLineComponent> matchingLines = null;
Action executeAction = () => matchingLines = targetBrand.YieldCartLinesWithBrand(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
matchingLines.Should().BeEmpty();
}
public bool Evaluate(IRuleExecutionContext context)
{
var contactOrders = _provider.GetContactOrders(context.Fact <Contact>(null));
return(contactOrders != null &&
contactOrders.Any(order => order.CartLines.Any(line => line.Product.ProductId == this.ProductID)));
}
public bool Evaluate(IRuleExecutionContext context)
{
string targetItemId = this.TargetItemId.Yield(context);
string storeName = this.StoreName.Yield(context);
CommerceContext commerceContext = context.Fact <CommerceContext>((string)null);
Cart cart = commerceContext != null?commerceContext.GetObject <Cart>() : (Cart)null;
if (cart == null || !cart.Lines.Any <CartLineComponent>() || (string.IsNullOrEmpty(targetItemId) || string.IsNullOrEmpty(storeName)))
{
return(false);
}
if (this.MatchingLines(context).Any <CartLineComponent>((Func <CartLineComponent, bool>)(l => l.HasComponent <CartProductComponent>())))
{
var cartShippingParty = cart.GetComponent <PhysicalFulfillmentComponent>().ShippingParty;
if (cartShippingParty != null)
{
return(cartShippingParty.AddressName.ToLower() == storeName.ToLower());
}
var cartLinesWithParty = cart.Lines.Where <CartLineComponent>(l => l.ItemId.Contains(targetItemId) && l.GetComponent <PhysicalFulfillmentComponent>().ShippingParty != null);
if (cartLinesWithParty.Count <CartLineComponent>() > 0)
{
return(cartLinesWithParty.Any <CartLineComponent>(
(Func <CartLineComponent, bool>)(
l => l.GetComponent <PhysicalFulfillmentComponent>().ShippingParty.AddressName.ToLower() == storeName.ToLower())));
}
}
return(false);
}
public void Execute_03_NoCartLines(
IRuleValue <string> targetTag,
Cart cart,
CartTotals cartTotals,
CommerceContext commerceContext,
CartItemTargetTagFreeGiftAction action,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
cart.Adjustments.Clear();
cart.Lines.Clear();
commerceContext.AddObject(cartTotals);
commerceContext.AddObject(cart);
action.TargetTag = targetTag;
context.Fact(Arg.Any <IFactIdentifier>()).Returns(commerceContext);
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
cart.Lines.SelectMany(l => l.Adjustments).Should().BeEmpty();
cart.Adjustments.Should().BeEmpty();
}
protected bool DoEvaluate(IRuleExecutionContext context)
{
Condition.Requires <IRuleExecutionContext>(context, nameof(context)).IsNotNull <IRuleExecutionContext>();
Contact contact = context.Fact <Contact>((string)null);
return(contact?.Interactions != null && this.IsMatch(contact));
}
public bool Evaluate(IRuleExecutionContext context)
{
var contact = context.Fact <Contact>();
return(Comparison.Evaluate(contact.GetFacet <CinemaDetails>(CinemaDetails.DefaultFacetKey)?.PreferredCinema, PreferredCinema) &&
contact.Interactions.Any());
}
public void Execute_02_NoCart(
BaseCartItemSubtotalAmountOffAction action,
IBinaryOperator <decimal, decimal> subtotalOperator,
IRuleValue <decimal> subtotal,
IRuleValue <decimal> amountOff,
CartTotals cartTotals,
CommerceContext commerceContext,
IRuleExecutionContext context)
{
/**********************************************
* Arrange
**********************************************/
context.Fact <CommerceContext>().ReturnsForAnyArgs(commerceContext);
commerceContext.AddObject(cartTotals);
action.SubtotalOperator = subtotalOperator;
action.Subtotal = subtotal;
action.AmountOff = amountOff;
/**********************************************
* Act
**********************************************/
Action executeAction = () => action.Execute(context);
/**********************************************
* Assert
**********************************************/
executeAction.Should().NotThrow <Exception>();
}
public bool Evaluate(IRuleExecutionContext context)
{
/* STUDENT: Complete the Evaluate method to:
* Retrieve the current temperature
* Compare it to the temperature stored in the Policy
* Return the result of that comparison
*/
var minimumTemperature = MinimumTemperature.Yield(context);
var city = City.Yield(context);
var country = Country.Yield(context);
CommerceContext commerceContext = context.Fact <CommerceContext>((string)null);
string openWeatherAPIKey = commerceContext.GetPolicy <WeatherServiceClientPolicy>().OpenWeatherAPIKey;
var currentTemperature = GetCurrentTemperature(city, country, openWeatherAPIKey);
if (currentTemperature > minimumTemperature)
{
return(true);
}
else
{
return(false);
}
// STUDENT: Replace this line. It is only provided so the stub
// project will build cleanly
}
public void ExecuteAllRulesAsyncShouldReturnResultsForAllRules([Frozen] IExeucutesSingleRule ruleExecutor,
SerialRuleExecutor sut,
[ExecutableModel] ExecutableRuleAndDependencies rule1,
[ExecutableModel] ExecutableRuleAndDependencies rule2,
[ExecutableModel] ExecutableRuleAndDependencies rule3,
IRuleExecutionContext executionContext,
[RuleResult] ValidationRuleResult result1,
[RuleResult] ValidationRuleResult result2,
[RuleResult] ValidationRuleResult result3)
{
var allRules = new[] { rule1, rule2, rule3 };
var sequence = new MockSequence();
Mock.Get(executionContext).InSequence(sequence).Setup(x => x.GetRulesWhichMayBeExecuted()).Returns(() => allRules.Select(r => r.ExecutableRule));
Mock.Get(executionContext).InSequence(sequence).Setup(x => x.GetRulesWhichMayBeExecuted()).Returns(() => Enumerable.Empty <ExecutableRule>());
Mock.Get(ruleExecutor)
.Setup(x => x.ExecuteRuleAsync(rule1.ExecutableRule, It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(result1));
Mock.Get(ruleExecutor)
.Setup(x => x.ExecuteRuleAsync(rule2.ExecutableRule, It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(result2));
Mock.Get(ruleExecutor)
.Setup(x => x.ExecuteRuleAsync(rule3.ExecutableRule, It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(result3));
Assert.That(async() => await sut.ExecuteAllRulesAsync(executionContext, default),
Is.EquivalentTo(new[] { result1, result2, result3 }));
}
public void Validate(IRuleExecutionContext ruleExecutionContext)
{
throw new NotImplementedException();
}
