public OrderProcessor(IGetObjectService <Order> getOrderService,
ITaxCalculator taxCalculator, IShippingCalculator shippingCalculator)
{
_getOrderService = getOrderService;
_taxCalculator = taxCalculator;
_shippingCalculator = shippingCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
// If we do this, then again it becomes a dependency on concrete class ShippingCalculator in OrderProcessor which we wanted to avoid in the first place
// hence passing IShippingCalculator as argument which we can assing concrete class during runtime either through Main method or Dependency Injection
// _shippingCalculator = new ShippingCalculator();
_shippingCalculator = shippingCalculator;
}
public DefaultOmniumOrderFactory(
IShippingCalculator shippingCalculator,
IMarketService marketService,
CultureResolver cultureResolver,
ITaxUtility taxUtility,
ReferenceConverter referenceConverter,
IContentRepository contentRepository,
IPaymentManagerFacade paymentManagerFacade,
ILineItemCalculator lineItemCalculator,
IOrderFormCalculator orderFormCalculator,
IOrderGroupCalculator orderGroupCalculator,
IShipmentManagerFacade shipmentManagerFacade,
IPromotionEngine promotionEngine)
{
_shippingCalculator = shippingCalculator;
_marketService = marketService;
_cultureResolver = cultureResolver;
_taxUtility = taxUtility;
_referenceConverter = referenceConverter;
_contentRepository = contentRepository;
_paymentManagerFacade = paymentManagerFacade;
_lineItemCalculator = lineItemCalculator;
_orderFormCalculator = orderFormCalculator;
_orderGroupCalculator = orderGroupCalculator;
_shipmentManagerFacade = shipmentManagerFacade;
_promotionEngine = promotionEngine;
}
private readonly IShippingCalculator _shippingCalculator;//intrface allow to make loosely coupled
public OrderProcessor(IShippingCalculator shipingCaculator)
{
//this makes orderprocessor class tightly coupling with shipment calculator
//if you need testing this coudnt able to perform isolated testing because of tightly coupeling
//_shippingCalculator = new ShippingCalculator();
_shippingCalculator = shipingCaculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
// _shippingCalculator = new ShippingCalculator();
// Now there is no reference to the ShippingCalculator concrete
// class. We are just referencing an interface.
_shippingCalculator = shippingCalculator;
}
public CustomizedTaxCalculator(IContentRepository contentRepository,
ReferenceConverter referenceConverter,
IShippingCalculator shippingCalculator)
{
_contentRepository = contentRepository;
_referenceConverter = referenceConverter;
_shippingCalculator = shippingCalculator;
}
public OrderSummaryViewModelFactory(
IOrderGroupCalculator orderGroupCalculator,
IShippingCalculator shippingCalculator,
ICurrencyService currencyService)
{
_orderGroupCalculator = orderGroupCalculator;
_shippingCalculator = shippingCalculator;
_currencyService = currencyService;
}
public OrderSummaryViewModelFactory(
IOrderGroupTotalsCalculator orderGroupTotalsCalculator,
IOrderGroupCalculator orderGroupCalculator,
IShippingCalculator shippingCalculator,
ICurrencyService currencyService)
{
_orderGroupTotalsCalculator = orderGroupTotalsCalculator;
_orderGroupCalculator = orderGroupCalculator;
_shippingCalculator = shippingCalculator;
_currencyService = currencyService;
}
public PayPalApiHelper(
IShippingCalculator shippingCalculator,
ITaxCalculator taxCalculator,
LocalizationService localizationService,
PayPalCurrencies paypalCurrencies)
{
_shippingCalculator = shippingCalculator;
_taxCalculator = taxCalculator;
_localizationService = localizationService;
_paypalCurrencies = paypalCurrencies;
}
public AuthorizeTokenExCimBasedManager(
AuthorizeTokenExService authorizeNetService,
IOrderGroupCalculator orderGroupCalculator,
IShippingCalculator shippingCalculator,
ILineItemCalculator lineItemCalculator,
IMarketService marketService)
{
_authorizeTokenExService = authorizeNetService;
_orderGroupCalculator = orderGroupCalculator;
_shippingCalculator = shippingCalculator;
_lineItemCalculator = lineItemCalculator;
_marketService = marketService;
}
public RequestFactory(
ICheckoutConfigurationLoader checkoutConfigurationLoader,
IOrderGroupCalculator orderGroupCalculator,
IShippingCalculator shippingCalculator,
SwedbankPayTaxCalculator swedbankPayTaxCalculator, IReturnLineItemCalculator returnLineItemCalculator)
{
_checkoutConfigurationLoader = checkoutConfigurationLoader ??
throw new ArgumentNullException(nameof(checkoutConfigurationLoader));
_orderGroupCalculator = orderGroupCalculator;
_shippingCalculator = shippingCalculator;
_swedbankPayTaxCalculator = swedbankPayTaxCalculator;
_returnLineItemCalculator = returnLineItemCalculator;
}
public SiteOmniumOrderFactory(
IShippingCalculator shippingCalculator,
IMarketService marketService,
CultureResolver cultureResolver,
ITaxUtility taxUtility,
ReferenceConverter referenceConverter,
IContentRepository contentRepository,
IPaymentManagerFacade paymentManagerFacade,
ILineItemCalculator lineItemCalculator,
IOrderFormCalculator orderFormCalculator,
IOrderGroupCalculator orderGroupCalculator,
IShipmentManagerFacade shipmentManagerFacade,
IPromotionEngine promotionEngine)
: base(shippingCalculator, marketService, cultureResolver, taxUtility, referenceConverter, contentRepository, paymentManagerFacade, lineItemCalculator, orderFormCalculator, orderGroupCalculator, shipmentManagerFacade, promotionEngine)
{
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
// _shippingCalculator = new ShippingCalculator();
_shippingCalculator = shippingCalculator;
}
public OrderProcesser(IShippingCalculator shippingCalculater)
{
_shippingCalculator = shippingCalculater;
}
public void Setup()
{
_defaultShippingCalculator = new ShippingCalculator();
_noWeekendShippingCalculator = new NoWeekendShippingCalculator();
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
//Tightly Coupled
_shippingCalculator = shippingCalculator;
}
public SiteOrderGroupCalculator(IOrderFormCalculator orderFormCalculator, IShippingCalculator shippingCalculator, ITaxCalculator taxCalculator)
: base(orderFormCalculator, shippingCalculator, taxCalculator)
{
_shippingCalculator = shippingCalculator;
_taxCalculator = taxCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator) // constructor
{
this.shippingCalculator = shippingCalculator;
}
public double CalculateShipping(IShippingCalculator shippingCalculator)
{
return(shippingCalculator.CalculateShipping(Subtotal));
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
_shippingCalculator = shippingCalculator; // no reference to ShippingCalculator concrete class
}
public OrderProcessor(ITaxCalculator taxCalculator, IShippingCalculator shippingCalculator)
{
this.taxCalculator = taxCalculator;
this.shippingCalculator = shippingCalculator;
}
public CheckOutEngine(IShippingCalculator shippingCalculator, IMapper mapper, ICouponEngine couponEngine)
{
_shippingCalculator = shippingCalculator;
_mapper = mapper;
_couponEngine = couponEngine;
}
public Calculator(IShippingCalculator shippingCalculator, IRepository <Product> productRepository)
{
_productRepository = productRepository;
_shippingCalculator = shippingCalculator;
}
public void Calculate(Cart cart, int prefID)
{
SitePreference shippingPreferences = CSFactory.GetCartPrefrence(cart);
if (shippingPreferences != null)
{
ShippingOptionType option = shippingPreferences.ShippingOptionId;
IShippingCalculator calculator = _allShippingCalculators[option];
calculator.Calculate(cart, shippingPreferences.ShippingPrefID);
//CodeReview: Instead of Cart pref and compute based on the admin pref
if (cart.ShippingMethod == UserShippingMethodType.Rush)
{
ShippingOptionType rushOption = shippingPreferences.RushShippingOptionID;
IShippingCalculator rushCalculator = _allRushShippingCalculators[rushOption];
rushCalculator.Calculate(cart, shippingPreferences.RushShippingPrefID);
}
else
{
cart.RushShippingCost = 0;
}
// code Review 10/09/2013
bool additionalShippingScenario = false;
bool additionalShippingScenarioWithSingleSKUinCart = false;
bool overRideShippingCostforAdditionalShippingScenario = false;
bool additionalShippingScenarioWithOtherItems = false;
Dictionary <string, string> dicSKUandPrice = new Dictionary <string, string>();
Dictionary <string, string> dicSKUShippingCostWithQtyRange = new Dictionary <string, string>();
Dictionary <string, XmlNode> dicSKUShippingCostWithQtyRangeList = new Dictionary <string, XmlNode>();
SitePreference sitePreference = CSFactory.GetCacheSitePref();
if (!sitePreference.AttributeValuesLoaded)
{
sitePreference.LoadAttributeValues();
}
if (sitePreference.AttributeValues.ContainsKey("additionalshippingscenario"))
{
if (sitePreference.AttributeValues["additionalshippingscenario"].Value != null)
{
additionalShippingScenario = sitePreference.AttributeValues["additionalshippingscenario"].BooleanValue;
}
}
if (sitePreference.AttributeValues.ContainsKey("additionalshippingscenariowithsingleskuincart"))
{
if (sitePreference.AttributeValues["additionalshippingscenariowithsingleskuincart"].Value != null)
{
additionalShippingScenarioWithSingleSKUinCart = sitePreference.AttributeValues["additionalshippingscenariowithsingleskuincart"].BooleanValue;
}
}
if (sitePreference.AttributeValues.ContainsKey("additionalshippingscenariowithotheritems"))
{
if (sitePreference.AttributeValues["additionalshippingscenariowithotheritems"].Value != null)
{
additionalShippingScenarioWithOtherItems = sitePreference.AttributeValues["additionalshippingscenariowithotheritems"].BooleanValue;
}
}
if (sitePreference.AttributeValues.ContainsKey("overrideshippingcostforadditionalshippingscenario"))
{
if (sitePreference.AttributeValues["overrideshippingcostforadditionalshippingscenario"].Value != null)
{
overRideShippingCostforAdditionalShippingScenario = sitePreference.AttributeValues["overrideshippingcostforadditionalshippingscenario"].BooleanValue;
}
}
string additionalShippingScenarioSKUandPrice = "";
if (sitePreference.AttributeValues.ContainsKey("additionalshippingscenarioskuandprice"))
{
if (sitePreference.AttributeValues["additionalshippingscenarioskuandprice"].Value != null)
{
additionalShippingScenarioSKUandPrice = sitePreference.AttributeValues["additionalshippingscenarioskuandprice"].Value.Trim();
}
}
if (additionalShippingScenario)
{
try
{
string dicKey = "";
string shippingcostwithqtyrange = "no";
if (!additionalShippingScenarioSKUandPrice.Equals(""))
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(additionalShippingScenarioSKUandPrice);
XmlNodeList resources = xml.SelectNodes("skulist/sku");
foreach (XmlNode node in resources)
{
dicKey = node.Attributes["skuid"].Value + "_" + node.Attributes["shippingprefid"].Value;
if (dicSKUandPrice.ContainsKey(dicKey) == false)
{
dicSKUandPrice.Add(dicKey, node.Attributes["shippingcost"].Value); // node.Attributes["skuid"].Value
}
shippingcostwithqtyrange = "no";
if (node.Attributes["shippingcostwithqtyrange"] != null)
{
if (node.Attributes["shippingcostwithqtyrange"].Value != null)
{
shippingcostwithqtyrange = node.Attributes["shippingcostwithqtyrange"].Value.ToLower();
XmlNode nodeQtyRangeList = node.SelectSingleNode("qtyrangelist");
if (nodeQtyRangeList != null)
{
if (dicSKUShippingCostWithQtyRangeList.ContainsKey(dicKey) == false)
{
dicSKUShippingCostWithQtyRangeList.Add(dicKey, nodeQtyRangeList);
}
}
}
}
if (dicSKUShippingCostWithQtyRange.ContainsKey(dicKey) == false)
{
dicSKUShippingCostWithQtyRange.Add(dicKey, shippingcostwithqtyrange);
}
}
}
else
{
dicSKUandPrice.Clear();
dicSKUShippingCostWithQtyRange.Clear();
dicSKUShippingCostWithQtyRangeList.Clear();
}
dicKey = "";
int lowerQty = 0;
int upperQty = 0;
string nodeName = "";
string nodeXml = "";
bool cartHasXMlItem = false;
foreach (Sku st in cart.CartItems)
{
string key = st.SkuId.ToString() + "_" + shippingPreferences.ShippingPrefID;
if (dicSKUandPrice.ContainsKey(key))
{
cartHasXMlItem = true;
break;
}
}
if (dicSKUandPrice.Count > 0 && cartHasXMlItem == true)
{
bool loopSingleSKUinCart = false;
if (additionalShippingScenarioWithSingleSKUinCart && cart.ItemCount == 1)
{
loopSingleSKUinCart = true;
decimal shippingCost = 0;
decimal skuShippingCost = 0;
bool isSKUPresent = false;
foreach (Sku st in cart.CartItems)
{
// if (st.SkuId == currentSetting.SkuId)
string key = st.SkuId.ToString() + "_" + shippingPreferences.ShippingPrefID;
if (dicSKUandPrice.ContainsKey(key))
{
isSKUPresent = true;
skuShippingCost = Convert.ToDecimal(dicSKUandPrice[key].ToString());
if (dicSKUShippingCostWithQtyRange[key].ToString().ToLower().Equals("yes") && dicSKUShippingCostWithQtyRangeList.ContainsKey(key) == true && dicSKUShippingCostWithQtyRange.ContainsKey(key) == true)
{
nodeName = (dicSKUShippingCostWithQtyRangeList[key]).Name;
nodeXml = "<" + nodeName + ">" + dicSKUShippingCostWithQtyRangeList[key].InnerXml.ToString() + "</" + nodeName + ">";
XmlDocument doc = new XmlDocument();
doc.LoadXml(nodeXml);
XmlNodeList nodeList = doc.SelectNodes("/" + nodeName + "/range");
foreach (XmlNode node in nodeList)
{
if (node.Attributes["lowerqty"] != null && node.Attributes["upperqty"] != null)
{
if (node.Attributes["lowerqty"].Value != null && node.Attributes["upperqty"].Value != null)
{
lowerQty = Convert.ToInt32(node.Attributes["lowerqty"].Value);
upperQty = Convert.ToInt32(node.Attributes["upperqty"].Value);
if (st.Quantity >= lowerQty && st.Quantity <= upperQty)
{
if (node.Attributes["shippingcostrange"] != null)
{
if (node.Attributes["shippingcostrange"].Value != null)
{
skuShippingCost = Convert.ToDecimal(node.Attributes["shippingcostrange"].Value);
break;
}
}
}
}
}
}
}
st.LoadAttributeValues();
if (st.AttributeValues.ContainsKey("shippingwithquantity"))
{
if (st.AttributeValues["shippingwithquantity"].Value == null)
{
shippingCost += skuShippingCost;
}
else if (st.AttributeValues["shippingwithquantity"].BooleanValue)
{
shippingCost += skuShippingCost * st.Quantity;
}
else
{
shippingCost += skuShippingCost;
}
}
else
{
shippingCost += skuShippingCost;
}
}
}
if (isSKUPresent)
{
if (overRideShippingCostforAdditionalShippingScenario)
{
cart.ShippingCost = shippingCost;
}
else
{
cart.ShippingCost += shippingCost;
}
cart.RushShippingCost = 0;
}
}
if (loopSingleSKUinCart == false)
{
if (additionalShippingScenarioWithOtherItems)
{
decimal shippingCost = 0;
decimal skuShippingCost = 0;
bool isSKUPresent = false;
foreach (Sku st in cart.CartItems)
{
// if (st.SkuId == currentSetting.SkuId)
string key = st.SkuId.ToString() + "_" + shippingPreferences.ShippingPrefID;
if (dicSKUandPrice.ContainsKey(key))
{
isSKUPresent = true;
skuShippingCost = Convert.ToDecimal(dicSKUandPrice[key].ToString());
if (dicSKUShippingCostWithQtyRange[key].ToString().ToLower().Equals("yes") && dicSKUShippingCostWithQtyRangeList.ContainsKey(key) == true && dicSKUShippingCostWithQtyRange.ContainsKey(key) == true)
{
nodeName = (dicSKUShippingCostWithQtyRangeList[key]).Name;
nodeXml = "<" + nodeName + ">" + dicSKUShippingCostWithQtyRangeList[key].InnerXml.ToString() + "</" + nodeName + ">";
XmlDocument doc = new XmlDocument();
doc.LoadXml(nodeXml);
XmlNodeList nodeList = doc.SelectNodes("/" + nodeName + "/range");
foreach (XmlNode node in nodeList)
{
if (node.Attributes["lowerqty"] != null && node.Attributes["upperqty"] != null)
{
if (node.Attributes["lowerqty"].Value != null && node.Attributes["upperqty"].Value != null)
{
lowerQty = Convert.ToInt32(node.Attributes["lowerqty"].Value);
upperQty = Convert.ToInt32(node.Attributes["upperqty"].Value);
if (st.Quantity >= lowerQty && st.Quantity <= upperQty)
{
if (node.Attributes["shippingcostrange"] != null)
{
if (node.Attributes["shippingcostrange"].Value != null)
{
skuShippingCost = Convert.ToDecimal(node.Attributes["shippingcostrange"].Value);
break;
}
}
}
}
}
}
}
st.LoadAttributeValues();
if (st.AttributeValues.ContainsKey("shippingwithquantity"))
{
if (st.AttributeValues["shippingwithquantity"].BooleanValue)
{
shippingCost += skuShippingCost * st.Quantity;
}
else
{
shippingCost += skuShippingCost;
}
}
else
{
shippingCost += skuShippingCost;
}
}
}
if (isSKUPresent)
{
if (overRideShippingCostforAdditionalShippingScenario)
{
cart.ShippingCost = shippingCost;
}
else
{
cart.ShippingCost += shippingCost;
}
cart.RushShippingCost = 0;
}
}
else
{
// Check here if cart has only items which in XML SKU List.
bool cartHasOnlyXMLSku = false;
foreach (Sku st in cart.CartItems)
{
string key = st.SkuId.ToString() + "_" + shippingPreferences.ShippingPrefID;
if (dicSKUandPrice.ContainsKey(key))
{
cartHasOnlyXMLSku = true;
}
else
{
cartHasOnlyXMLSku = false;
break;
}
}
if (cartHasOnlyXMLSku)
{
decimal shippingCost = 0;
decimal skuShippingCost = 0;
bool isSKUPresent = false;
foreach (Sku st in cart.CartItems)
{
// if (st.SkuId == currentSetting.SkuId)
string key = st.SkuId.ToString() + "_" + shippingPreferences.ShippingPrefID;
if (dicSKUandPrice.ContainsKey(key))
{
isSKUPresent = true;
skuShippingCost = Convert.ToDecimal(dicSKUandPrice[key].ToString());
if (dicSKUShippingCostWithQtyRange[key].ToString().ToLower().Equals("yes") && dicSKUShippingCostWithQtyRangeList.ContainsKey(key) == true && dicSKUShippingCostWithQtyRange.ContainsKey(key) == true)
{
nodeName = (dicSKUShippingCostWithQtyRangeList[key]).Name;
nodeXml = "<" + nodeName + ">" + dicSKUShippingCostWithQtyRangeList[key].InnerXml.ToString() + "</" + nodeName + ">";
XmlDocument doc = new XmlDocument();
doc.LoadXml(nodeXml);
XmlNodeList nodeList = doc.SelectNodes("/" + nodeName + "/range");
foreach (XmlNode node in nodeList)
{
if (node.Attributes["lowerqty"] != null && node.Attributes["upperqty"] != null)
{
if (node.Attributes["lowerqty"].Value != null && node.Attributes["upperqty"].Value != null)
{
lowerQty = Convert.ToInt32(node.Attributes["lowerqty"].Value);
upperQty = Convert.ToInt32(node.Attributes["upperqty"].Value);
if (st.Quantity >= lowerQty && st.Quantity <= upperQty)
{
if (node.Attributes["shippingcostrange"] != null)
{
if (node.Attributes["shippingcostrange"].Value != null)
{
skuShippingCost = Convert.ToDecimal(node.Attributes["shippingcostrange"].Value);
break;
}
}
}
}
}
}
}
st.LoadAttributeValues();
if (st.AttributeValues.ContainsKey("shippingwithquantity"))
{
if (st.AttributeValues["shippingwithquantity"].BooleanValue)
{
shippingCost += skuShippingCost * st.Quantity;
}
else
{
shippingCost += skuShippingCost;
}
}
else
{
shippingCost += skuShippingCost;
}
}
}
if (isSKUPresent)
{
if (overRideShippingCostforAdditionalShippingScenario)
{
cart.ShippingCost = shippingCost;
}
else
{
cart.ShippingCost += shippingCost;
}
cart.RushShippingCost = 0;
}
}
}
}
}
}
catch (Exception ex)
{
CSCore.CSLogger.Instance.LogException("Additional Shipping Scenario Calculation Issue ", ex);
throw;
}
}
}
else
{
throw new InvalidOperationException("Missing shipping preferences");
}
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
_shippingCalculator = shippingCalculator;
}
public ShippingCostCalculator(IShippingCalculator calculator)
{
Calculator = calculator;
}
private readonly IShippingCalculator _shippingCalculator;//isolating a class using a interface
public OrderProcessor(IShippingCalculator shippingCalculator)
{
_shippingCalculator = shippingCalculator;//loose coupling
}
public SiteOrderGroupCalculator(IOrderFormCalculator orderFormCalculator, IShippingCalculator shippingCalculator, ITaxCalculator taxCalculator)
: base(orderFormCalculator, shippingCalculator, taxCalculator)
{
_shippingCalculator = shippingCalculator;
_taxCalculator = taxCalculator;
}
public GetBasketQuery()
{
_shippingCalculator = new ShippingCalculator();
}
public OrderProcessor(IShippingCalculator _shipmentCalculator)
{
this._shipmentCalculator = _shipmentCalculator;
}
// constructor
public OrderProcessor(IShippingCalculator shippingCalculator)
{
//use constructor
_shippingCalculator = shippingCalculator;
}
public GetBasketQuery()
{
_shippingCalculator = new ShippingCalculator();
}
public SiteOrderFormCalculator(IShippingCalculator shippingCalculator, ILineItemCalculator lineItemCalculator, ITaxCalculator taxCalculator)
: base(shippingCalculator, taxCalculator)
{
_lineItemCalculator = lineItemCalculator;
}
public SiteOrderFormCalculator(IShippingCalculator shippingCalculator, ILineItemCalculator lineItemCalculator, ITaxCalculator taxCalculator)
: base(shippingCalculator, lineItemCalculator, taxCalculator)
{
_lineItemCalculator = lineItemCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
//_shippingCalculator = new ShippingCalculator();
_shippingCalculator = shippingCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator) // We are referencing an interface
{
_shippingCalculator = shippingCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
_shippingCalculator = shippingCalculator;
}
public OrderProcessor(IShippingCalculator shippingCalculator)
{
//_shippingCalculator = new ShippingCalculator();
//實體改從執行時再注入，由外部決定。=> 依賴性注入
_shippingCalculator = shippingCalculator;
}
