internal static Dictionary <ItemUnitConversion, UnitOfMeasureConversion> GetUnitOfMeasureConversions(RequestContext context, IEnumerable <ItemUnitConversion> itemUnitConversions) { IEnumerable <ItemUnitConversion> distinctItemUnitConversions = itemUnitConversions .Where(itemUnitConversion => !itemUnitConversion.IsNop) .Distinct(); var getUomConvertionDataRequest = new GetUnitOfMeasureConversionDataRequest(distinctItemUnitConversions, QueryResultSettings.AllRecords); IEnumerable <UnitOfMeasureConversion> unitOfMeasureConversions = context.Runtime .Execute <GetUnitOfMeasureConversionDataResponse>(getUomConvertionDataRequest, context).UnitConversions.Results; return(unitOfMeasureConversions.ToDictionary(unitOfMeasureConversion => new ItemUnitConversion() { ItemId = unitOfMeasureConversion.ItemId, FromUnitOfMeasure = unitOfMeasureConversion.FromUnitOfMeasureSymbol, ToUnitOfMeasure = unitOfMeasureConversion.ToUnitOfMeasureSymbol, })); }
private static GetUnitOfMeasureConversionDataResponse GetUnitOfMeasureConversion(GetUnitOfMeasureConversionDataRequest request) { var getUnitOfMeasureConversionProcedure = new GetUnitOfMeasureConversionProcedure(request); return(getUnitOfMeasureConversionProcedure.Execute()); }
/// <summary> /// Calculate the tax bases calculationBase and limitBase (which is zero for India). /// </summary> /// <param name="codes">The tax codes.</param> /// <param name="taxInStoreCurrency">If set to <c>true</c> [tax in store currency].</param> /// <param name="calculateBasePrice">If set to <c>true</c> [Calculate the base price].</param> /// <returns>The calculation base as Item1 and The limit base as Item2 in Tuple.</returns> protected override Tuple <decimal, decimal> GetBases(ReadOnlyCollection <TaxCode> codes, bool taxInStoreCurrency, bool calculateBasePrice) { const decimal LimitBase = decimal.Zero; decimal calculationBase; // For amount by unit calculation base is just the quantity. if (this.TaxBase == TaxBase.AmountByUnit) { calculationBase = this.TaxableEntity.Quantity; // If the tax is calculated in a different UOM, then convert if possible // this is only applicable for lineItem taxes. SalesLine salesLine = this.TaxableEntity as SalesLine; if (salesLine != null && !string.Equals(this.Unit, this.TaxableEntity.SalesOrderUnitOfMeasure, StringComparison.OrdinalIgnoreCase)) { ItemUnitConversion conversion = new ItemUnitConversion { FromUnitOfMeasure = this.TaxableEntity.SalesOrderUnitOfMeasure, ToUnitOfMeasure = this.Unit, ItemId = this.TaxableEntity.ItemId }; var conversions = new List <ItemUnitConversion>(); conversions.Add(conversion); var getUomConvertionDataRequest = new GetUnitOfMeasureConversionDataRequest(conversions, QueryResultSettings.SingleRecord); UnitOfMeasureConversion converter = this.RequestContext.Runtime .Execute <GetUnitOfMeasureConversionDataResponse>(getUomConvertionDataRequest, this.RequestContext).UnitConversions.SingleOrDefault(); calculationBase *= converter.GetFactorForQuantity(this.TaxableEntity.Quantity); } return(new Tuple <decimal, decimal>(calculationBase, LimitBase)); } // Determine the starting calculation base (includes the line price or not) switch (this.Formula.TaxableBasis) { case TaxableBasisIndia.LineAmount: calculationBase = this.TaxableEntity.NetAmountWithAllInclusiveTaxPerUnit; break; case TaxableBasisIndia.MaxRetailPrice: calculationBase = this.GetItemMaxRetailPrice(); break; default: calculationBase = decimal.Zero; break; } if (this.TaxIncludedInPrice) { calculationBase = GetBasePriceForTaxIncluded(calculationBase, codes, this.Formula, this.RequestContext); } calculationBase *= Math.Abs(this.TaxableEntity.Quantity); // Calculation expression is of the form: +[BCD]+[CVD]+[E-CESS_CVD]+[PE-C_CVD]+[SHE-C_CVD] // where the brackets are replaced with the delimiter char(164) // and BCD, CVD ... are tax codes. // The operator may be + - / *. string[] tokens = this.Formula.ParseExpression(); for (int index = 1; index < tokens.Length; index += 2) { TaxLine taxLine = (from line in this.TaxableEntity.TaxLines where line.TaxCode == tokens[index] select line).FirstOrDefault(); if (taxLine != null) { this.IsTaxOnTax = true; if (!this.taxCodesInFormula.Contains(taxLine.TaxCode)) { this.taxCodesInFormula.Add(taxLine.TaxCode); } } decimal amount = taxLine == null ? decimal.Zero : taxLine.Amount * Math.Sign(this.TaxableEntity.Quantity); int tokenNumber = index - 1; switch (tokens[tokenNumber]) { case "+": calculationBase += amount; break; case "-": calculationBase -= amount; break; case "*": calculationBase *= amount; break; case "/": calculationBase = amount == decimal.Zero ? calculationBase : calculationBase /= amount; break; default: RetailLogger.Log.CrtServicesTaxCodeIndiaTaxServiceInvalidOperatorFoundInBaseCalculation(tokens[tokenNumber]); break; } } // Knock any abatement off of the taxable basis calculationBase *= (100 - this.AbatementPercent) / 100; return(new Tuple <decimal, decimal>(calculationBase, LimitBase)); }
private static GetUnitOfMeasureConversionDataResponse GetUnitOfMeasureConversion(GetUnitOfMeasureConversionDataRequest request) { ThrowIf.Null(request, "request"); ThrowIf.Null(request.ItemUnitConversions, "request.ItemUnitConversions"); ThrowIf.Null(request.QueryResultSettings, "request.QueryResultSettings"); var query = new SqlPagedQuery(request.QueryResultSettings) { From = GetUnitOfMeasureConversionsFunctionName, OrderBy = "ITEMID, FROMUNITID, TOUNITID", }; PagedResult <UnitOfMeasureConversion> unitOfMeasureConversions; using (ItemUnitConversionTableType type = new ItemUnitConversionTableType(request.ItemUnitConversions)) { query.Parameters[DataAreaIdVariableName] = request.RequestContext.GetChannelConfiguration().InventLocationDataAreaId; query.Parameters[ItemUnitConversionsTableType] = type.DataTable; using (var sqlServerDatabaseContext = new SqlServerDatabaseContext(request)) { unitOfMeasureConversions = sqlServerDatabaseContext.ReadEntity <UnitOfMeasureConversion>(query); } } return(new GetUnitOfMeasureConversionDataResponse(unitOfMeasureConversions)); }
/// <summary> /// Initializes a new instance of the <see cref="GetUnitOfMeasureConversionProcedure"/> class. /// </summary> /// <param name="request">The request object.</param> public GetUnitOfMeasureConversionProcedure(GetUnitOfMeasureConversionDataRequest request) { this.request = request; }
/// <summary> /// Gets the bases for tax calculations. /// </summary> /// <param name="codes">The collection of tax codes.</param> /// <param name="taxInStoreCurrency">If set to <c>true</c>, tax amount is in the store's currency.</param> /// <param name="calculateBasePrice">If set to <c>true</c>, calculate the base price.</param> /// <returns>The calculation base and The limit base in <see cref="Tuple">Tuple</see>.</returns> protected virtual Tuple <decimal, decimal> GetBases( ReadOnlyCollection <TaxCode> codes, bool taxInStoreCurrency, bool calculateBasePrice) { decimal calculationBase; decimal limitBase; decimal basePrice = decimal.Zero; if (calculateBasePrice) { basePrice = this.TaxIncludedInPrice ? TaxCodeProvider.GetBasePriceForTaxIncluded(this.TaxableEntity, codes, this.TaxContext) : this.TaxableEntity.NetAmountPerUnit + GetApplicableDutyTaxes(this.TaxableEntity, codes); } // 1. Get initial value for the Calculation Base switch (this.TaxBase) { case TaxBase.PercentPerTax: // Base is the amount of the other tax switch (this.TaxLimitBase) { case TaxLimitBase.InvoiceWithoutVat: case TaxLimitBase.InvoiceWithVat: calculationBase = Math.Abs(this.CalculateTaxOnTax(this.Transaction)); break; case TaxLimitBase.UnitWithoutVat: case TaxLimitBase.UnitWithVat: // if this tax's Limit is per-unit, then we need to convert the existing tax amounts from per-line to per-unit decimal quantity = (this.TaxableEntity.Quantity == decimal.Zero) ? decimal.One : this.TaxableEntity.Quantity; calculationBase = Math.Abs(this.CalculateTaxOnTax()) / Math.Abs(quantity); break; default: calculationBase = Math.Abs(this.CalculateTaxOnTax()); break; } break; case TaxBase.PercentPerGross: // Base is the price + other taxes calculationBase = basePrice; // If the Limit base is NOT per-unit, then we need to factor in the line quanity if (TaxLimitBase != TaxLimitBase.UnitWithoutVat && TaxLimitBase != TaxLimitBase.UnitWithVat) { calculationBase *= Math.Abs(this.TaxableEntity.Quantity); } if (!string.IsNullOrEmpty(this.TaxOnTax)) { // Base is the Price + the amount of a single other tax calculationBase += Math.Abs(this.CalculateTaxOnTax()); } else { // Base is the Price + all other taxes calculationBase += Math.Abs(TaxCode.SumAllTaxAmounts(this.TaxableEntity)); } break; case TaxBase.AmountByUnit: calculationBase = this.AmountPerUnitCalculationBase; break; case TaxBase.PercentPerNet: case TaxBase.PercentGrossOnNet: default: // Base is the Price calculationBase = basePrice; // If the Limit base is NOT per-unit, then we need to factor in the line quanity if (TaxLimitBase != TaxLimitBase.UnitWithoutVat && TaxLimitBase != TaxLimitBase.UnitWithVat) { calculationBase *= Math.Abs(this.TaxableEntity.Quantity); } break; } // 3. Set Limit Base if (this.TaxBase == TaxBase.AmountByUnit) { // Base for limits/intervals is base-quantity * price limitBase = calculationBase * basePrice; // Convert limit base to Tax currency, if different if (!taxInStoreCurrency) { limitBase = this.TaxContext.TaxCurrencyOperations.ConvertCurrency(this.TaxContext.ChannelCurrency, this.Currency, limitBase); } // If the tax is calculated in a different UOM, then convert if possible // this is only applicable for lineItem taxes. SalesLine salesLine = this.TaxableEntity as SalesLine; if (salesLine != null && !string.Equals(this.Unit, this.TaxableEntity.SalesOrderUnitOfMeasure, StringComparison.OrdinalIgnoreCase)) { ItemUnitConversion conversion = new ItemUnitConversion { FromUnitOfMeasure = this.TaxableEntity.SalesOrderUnitOfMeasure, ToUnitOfMeasure = this.Unit, ItemId = this.TaxableEntity.ItemId }; var conversions = new List <ItemUnitConversion>(); conversions.Add(conversion); var getUomConvertionDataRequest = new GetUnitOfMeasureConversionDataRequest(conversions, QueryResultSettings.SingleRecord); UnitOfMeasureConversion converter = this.RequestContext.Runtime .Execute <GetUnitOfMeasureConversionDataResponse>(getUomConvertionDataRequest, this.RequestContext).UnitConversions.SingleOrDefault(); calculationBase *= converter.GetFactorForQuantity(this.TaxableEntity.Quantity); } } else { // Convert base to Tax currency, if different if (!taxInStoreCurrency) { calculationBase = this.TaxContext.TaxCurrencyOperations.ConvertCurrency(this.TaxContext.ChannelCurrency, this.Currency, calculationBase); } // Base for limits/intervals is same for Calculations limitBase = calculationBase; } return(new Tuple <decimal, decimal>(calculationBase, limitBase)); }