private static void Strategy()
{
#region Strategy
decimal a = 10;
decimal b = 5;
CalculatorContext calculatorContext = new CalculatorContext();
calculatorContext.SetStrategy(new StrategyAddition());
Console.WriteLine("Resultado: " + calculatorContext.Calculate(a, b));
calculatorContext.SetStrategy(new StrategySubtraction());
Console.WriteLine("Resultado: " + calculatorContext.Calculate(a, b));
calculatorContext.SetStrategy(new StrategyMultiplication());
Console.WriteLine("Resultado: " + calculatorContext.Calculate(a, b));
calculatorContext.SetStrategy(new StrategyDivision());
Console.WriteLine("Resultado: " + calculatorContext.Calculate(a, b));
calculatorContext.SetStrategy(new StrategyExponentiation());
Console.WriteLine("Resultado: " + calculatorContext.Calculate(a, b));
#endregion Strategy
}
public MainViewModel()
{
CalculatorContext context = new CalculatorContext();
_operations = new Operations();
_repository = new NumberRepository(context);
}
public SearchHistoryService(
CalculatorContext context,
ICityService cityService)
{
this.context = context;
this.cityService = cityService;
}
public void TestNinject()
{
// Arrange
List <string> mylist = new List <string>(new string[] { "121556550", "15589455452", "2254564555565552", "5554525455454554565" });
StandardKernel kernel = new StandardKernel();
// Load Modules
// Assemblies of the current project (Assemblies in Unit Test).
//kernel.Load(Assembly.GetExecutingAssembly());
// Assemblies of the solution (Assemblies in all projects).
kernel.Load(AppDomain.CurrentDomain.GetAssemblies());
CalculatorContext calculatorContext = null;
try
{
// Gets a instance of the specified service.
SumStrategy objCalculate = kernel.Get <SumStrategy>(); //("Sum");
MultipleStrategy objCalculate2 = kernel.Get <MultipleStrategy>(); // ("Multiple");
// Act: Inject
calculatorContext = new CalculatorContext(objCalculate, objCalculate2);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
// Assert
Assert.AreEqual(calculatorContext.Sum(mylist), "5556780035721132119");
}
private async Task EnsureAssociatedProductsAreLoaded(Product product, CalculatorContext context)
{
var options = context.Options;
if (context.AssociatedProducts == null)
{
// Associated products have not been preloaded unfortunately. Get 'em here for this particular product.
var searchQuery = new CatalogSearchQuery()
.PublishedOnly(true)
.HasStoreId(options.Store.Id)
.HasParentGroupedProduct(product.Id);
var searchResult = await _catalogSearchService.SearchAsync(searchQuery);
context.AssociatedProducts = (await searchResult.GetHitsAsync()).OrderBy(x => x.DisplayOrder).ToList();
}
if (options.ChildProductsBatchContext == null && context.AssociatedProducts.Any())
{
// No batch context given for the listing batch, so create one for associated products of this particular product.
options.ChildProductsBatchContext = _productService.CreateProductBatchContext(context.AssociatedProducts, options.Store, options.Customer, false);
}
// Continue pipeline with AssociatedProductsBatchContext
options.BatchContext = options.ChildProductsBatchContext;
}
public CalculatorCostService(CalculatorContext context, ICityService cityService, IModuleService moduleService, ISearchHistoryService searchHistoryService)
{
this.context = context;
this.cityService = cityService;
this.moduleService = moduleService;
this.searchHistoryService = searchHistoryService;
}
public async Task CalculateAsync(CalculatorContext context, CalculatorDelegate next)
{
var product = context.Product;
var options = context.Options;
// Ignore tier prices of bundle items (BundlePerItemPricing).
var processTierPrices = !options.IgnoreTierPrices && !options.IgnoreDiscounts && product.HasTierPrices && context.BundleItem?.Item == null;
if (processTierPrices)
{
var tierPrices = await context.GetTierPricesAsync();
// Put minimum tier price to context because it's required for discount calculation.
context.MinTierPrice = GetMinimumTierPrice(product, tierPrices, context.Quantity);
if (context.Options.DetermineLowestPrice && !context.HasPriceRange)
{
context.HasPriceRange = tierPrices.Any() && !(tierPrices.Count == 1 && tierPrices.First().Quantity <= 1);
}
}
// Process the whole pipeline. We need the result of discount calculation.
await next(context);
if (processTierPrices && context.MinTierPrice.HasValue)
{
// Apply the minimum tier price if it achieves a lower price than the discounted FinalPrice.
context.FinalPrice = Math.Min(context.FinalPrice, context.MinTierPrice.Value);
}
}
public override CalculatorContext Invoke(CalculatorContext ctx)
{
var newCtx = ctx.Copy();
newCtx.Reset();
return(newCtx);
}
protected internal override void Sub(CalculatorContext context, Stack <string> stack)
{
Calculator ctxt = context.Owner;
if (stack.Count >= 2)
{
CalculatorState endState = context.State;
context.ClearState();
try
{
ctxt.Sub();
}
finally
{
context.State = endState;
}
}
else
{
context.State.Exit(context);
context.State = Map1.ErrorTuple;
context.State.Entry(context);
}
return;
}
static void Main(string[] args)
{
while (true)
{
context = new CalculatorContext();
Console.WriteLine("Hello, welcome to the Strategy Pattern PoC.");
Console.WriteLine("Please, select your Calculation method:");
Console.WriteLine(Environment.NewLine + "1 - Addition");
Console.WriteLine(Environment.NewLine + "2 - Subtraction");
Console.WriteLine(Environment.NewLine + "3 - Multiplication");
var inputChoice = Convert.ToInt32(Console.ReadLine());
var strategy = context.GetCorrectStrategy(inputChoice);
if (strategy == "AdditionStrategy")
{
context.SetStrategy(new AdditionStrategy());
}
else if (strategy == "SubtractionStrategy")
{
context.SetStrategy(new SubtractionStrategy());
}
else if (strategy == "MultiplicationStrategy")
{
context.SetStrategy(new MultiplicationStrategy());
}
Console.WriteLine("Please, enter enter in the first number");
var firstNumber = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Please, enter enter in the second number");
var secondNumber = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Answer:");
Console.WriteLine(context.ExecuteStrategy(firstNumber, secondNumber));
}
}
public List <Operators> GetOperators()
{
using (var context = new CalculatorContext())
{
return(context.Operators.ToList());
}
}
public async Task CalculateAsync(CalculatorContext context, CalculatorDelegate next)
{
if (context.Options.IgnoreOfferPrice)
{
// Ignore offer price for this calculation.
await next(context);
return;
}
var product = context.Product;
if (product.SpecialPrice.HasValue)
{
// Check date range.
var now = DateTime.UtcNow;
var from = product.SpecialPriceStartDateTimeUtc;
var to = product.SpecialPriceEndDateTimeUtc;
if ((from == null || now >= from) && (to == null || now <= to))
{
context.OfferPrice = product.SpecialPrice;
context.FinalPrice = product.SpecialPrice.Value;
}
}
await next(context);
}
protected internal override void Enter(CalculatorContext context, string value)
{
Calculator ctxt = context.Owner;
if (double.TryParse(value, out double _))
{
context.State.Exit(context);
context.ClearState();
try
{
ctxt.Push(value);
}
finally
{
context.State = Map1.Calculate;
context.State.Entry(context);
}
}
else
{
context.State.Exit(context);
context.State = Map1.ErrorNumeric;
context.State.Entry(context);
}
return;
}
public HomeController(CalculatorContext dbContext,
UserManager <AspNetUsers> userManager,
SignInManager <AspNetUsers> signInManager)
{
_dbContext = dbContext;
_userManager = userManager;
_signInManager = signInManager;
}
public List <Operation> GetQueue()
{
using (var db = new CalculatorContext(configuration.DbConnectionString))
{
return(db.Operations.AsNoTracking().OrderBy(q => q.OperationId)
.ToArray().Select(source => dtoOperationMapper.Map(source)).ToList());
}
}
public void Setup()
{
var calculatorContext = new CalculatorContext();
_calculatorHelper = new CalculatorHelper();
_calculator = new Calculator(calculatorContext);
_calculatorHelper.SetupCalculator(_calculator);
}
protected internal virtual void Default(CalculatorContext context)
{
throw (
new statemap.TransitionUndefinedException(
"State: " +
context.State.Name +
", Transition: " +
context.GetTransition()));
}
public CalculationsController(
ITaxCalculatorFactory factory,
CalculatorContext context,
ILogger <CalculationsController> logger)
{
_factory = factory;
_context = context;
_logger = logger;
}
protected internal override void Enter(CalculatorContext context, string value)
{
context.State.Exit(context);
context.State = Map1.Enter;
context.State.Entry(context);
return;
}
public override async Task CalculateAsync(CalculatorContext context, CalculatorDelegate next)
{
var product = context.Product;
if (product.ProductType != ProductType.GroupedProduct)
{
// Proceed with pipeline and omit this calculator, it is made for grouped products only.
await next(context);
return;
}
var options = context.Options;
if (options.IgnoreGroupedProducts)
{
await next(context);
return;
}
await EnsureAssociatedProductsAreLoaded(product, context);
if (context.AssociatedProducts.Count == 0)
{
// No children, get out.
return;
}
CalculatorContext lowestPriceCalculation = null;
if (options.DetermineLowestPrice && context.AssociatedProducts.Count > 1)
{
foreach (var associatedProduct in context.AssociatedProducts)
{
// Get the final price of associated product
var childCalculation = await CalculateChildPriceAsync(associatedProduct, context);
if (lowestPriceCalculation == null || childCalculation.FinalPrice < lowestPriceCalculation.FinalPrice)
{
// Set the lowest price calculation
lowestPriceCalculation = childCalculation;
}
}
lowestPriceCalculation.HasPriceRange = true;
}
else
{
// Get the final price of first associated product
lowestPriceCalculation = await CalculateChildPriceAsync(context.AssociatedProducts.First(), context);
}
// Copy data from child context to this context
lowestPriceCalculation.CopyTo(context);
}
public void AddToQueue(Operation operation)
{
using (var db = new CalculatorContext(configuration.DbConnectionString))
{
var dbOperation = dbOperationMapper.Map(operation);
dbOperation.CalculatorId = configuration.CalculatorId;
db.Operations.Add(dbOperation);
db.SaveChanges();
}
}
protected override ICalculatorState OnClear(Clear clear)
{
if (_hasNewOperand)
{
_tempCtx = clear.Invoke(_tempCtx);
return(this);
}
return(new OperandState(clear.Invoke(Ctx)));
}
public HistoricalViewModel()
{
_id = UserService.UserService.LoggedInUserId;
_context = new CalculatorContext();
_numberRepository = new NumberRepository(_context);
_numbersList = new ObservableCollection <string>();
numbersList = new List <string>();
numbersList = _numberRepository.GetUserNumbersList(_id);
numbersList.ToList().ForEach(_numbersList.Add);
}
public double CalculateFor(Coupon coupon, double totalAmount)
{
if (totalAmount < coupon.MinimumPurchaseAmount)
{
return(default(double));
}
var discountCalculatorContext = new CalculatorContext(coupon.DiscountType, coupon.AmountOfDiscount, totalAmount);
return(discountCalculatorContext.Calculate());
}
public void IsSet()
{
var order = new OrderCarrier();
using (CalculatorContext.Use(order))
{
Assert.Same(order, CalculatorContext.GetCurrentOrderCarrier());
}
Assert.Null(CalculatorContext.GetCurrentOrderCarrier());
}
private async Task ProcessAnnualSalaryStrategy(List <EmployeeEntity> entities)
{
var calculatorContext = new CalculatorContext();
foreach (var item in entities)
{
var type = (AnnualSalaryStrategy.CalculationTypes)System.Enum
.Parse(typeof(AnnualSalaryStrategy.CalculationTypes), item.ContractTypeName);
item.CalculatedAnnualSalary = await calculatorContext.calculators[type].CalculateAnnualSalaryAsync(item);
}
}
public void Calculate(CalculatorContext memory)
{
//memory.PopNumber();
if (memory.Count() < 2)
{
throw new SyntaxErrorException();
}
var exp1 = memory.PopNumber();
var exp2 = memory.PopNumber();
memory.PushNumber(new Number(exp2.Value * exp1.Value));
}
public async Task CalculateAsync(CalculatorContext context, CalculatorDelegate next)
{
var product = context.Product;
var bundleItem = context.BundleItem;
Discount appliedDiscount = null;
if (bundleItem?.Item != null)
{
var bi = bundleItem.Item;
if (bi.Discount.HasValue && bi.BundleProduct.BundlePerItemPricing)
{
appliedDiscount = new Discount
{
UsePercentage = bi.DiscountPercentage,
DiscountPercentage = bi.Discount.Value,
DiscountAmount = bi.Discount.Value
};
context.AppliedDiscounts.Add(appliedDiscount);
var discountAmount = appliedDiscount.GetDiscountAmount(context.FinalPrice);
context.FinalPrice -= discountAmount;
}
}
else if (!context.Options.IgnoreDiscounts && !product.CustomerEntersPrice)
{
// Don't calculate when customer entered price or discounts should be ignored in any case.
var applicableDiscounts = await GetApplicableDiscounts(product, context);
if (applicableDiscounts.Any())
{
appliedDiscount = applicableDiscounts.GetPreferredDiscount(context.FinalPrice);
if (appliedDiscount != null)
{
context.AppliedDiscounts.Add(appliedDiscount);
var discountAmount = appliedDiscount.GetDiscountAmount(context.FinalPrice);
context.FinalPrice -= discountAmount;
}
}
}
// Percentage discount on minimum tier price.
if (!context.Options.IgnorePercentageDiscountOnTierPrices &&
context.MinTierPrice.HasValue &&
context.MinTierPrice != decimal.Zero &&
appliedDiscount != null &&
appliedDiscount.UsePercentage)
{
context.FinalPrice -= appliedDiscount.GetDiscountAmount(context.MinTierPrice.Value);
}
await next(context);
}
public async Task CalculateAsync(CalculatorContext context, CalculatorDelegate next)
{
if (!context.Options.DetermineLowestPrice)
{
// Proceed with pipeline and omit this calculator, it is made for lowest price calculation only.
await next(context);
return;
}
// Process the whole pipeline with maximum quantity to get the minimum tier price applied.
context.Quantity = int.MaxValue;
await next(context);
// Get lowest possible price.
var product = context.Product;
var lowestPrice = context.FinalPrice;
var forceApply = false;
if (product.LowestAttributeCombinationPrice.HasValue && product.LowestAttributeCombinationPrice.Value < lowestPrice)
{
lowestPrice = product.LowestAttributeCombinationPrice.Value;
}
if (lowestPrice == decimal.Zero && product.Price == decimal.Zero)
{
// Do not display 0 as lowest price.
forceApply = true;
lowestPrice = product.LowestAttributeCombinationPrice ?? decimal.Zero;
}
// Apply lowest price.
if (lowestPrice < context.FinalPrice || forceApply)
{
context.FinalPrice = lowestPrice;
}
context.LowestPrice = context.FinalPrice;
// Check whether the product has a price range.
if (!context.HasPriceRange)
{
context.HasPriceRange = product.LowestAttributeCombinationPrice.HasValue;
}
if (!context.HasPriceRange)
{
var attributes = await context.Options.BatchContext.Attributes.GetOrLoadAsync(product.Id);
context.HasPriceRange = attributes.Any(x => x.ProductVariantAttributeValues.Any(y => y.PriceAdjustment != decimal.Zero));
}
}
public void RemoveOperationFromQueueByOperationId(int operationId)
{
using (var db = new CalculatorContext(configuration.DbConnectionString))
{
var dbOperation = db.Operations.FirstOrDefault(x => x.OperationId == operationId);
if (dbOperation == null)
{
return;
}
db.Operations.Remove(dbOperation);
db.SaveChanges();
}
}
public int Calculate(CalculatorContext context)
{
return context.Calculator.Operation(context.Operator, context.Left, context.Right);
}
