Пример #1
0
        private async Task <ResolvedRatesResult> CalculateInterestRates(PriceCalculationParameters calculationParameters, VariationDefinitionParams definitionParams)
        {
            var bundleVariationGroup = await configurationService
                                       .GetEffective("offer/price-calculation/bundle-variation-group", "PRODUCT-BUNDLING-DISCOUNT");

            bundleVariationGroup = bundleVariationGroup.ToLower();

            var result = new ResolvedRatesResult
            {
                ResultChanged = false
            };

            if (calculationParameters.InterestRates != null)
            {
                result.Rates = new List <InterestRateCondition>();
                var     arrRates = calculationParameters.InterestRates;
                decimal napr     = -1;
                foreach (InterestRateCondition rate in arrRates)
                {
                    var oldCalculatedRate = rate.CalculatedRate;
                    if (
                        // check if rate is defined at all
                        rate == null ||
                        // check if rate is effective on request date
                        rate.EffectiveDate > calculationParameters.RequestDate ||
                        // check if rate is defined for main currency
                        (rate.Currencies != null && !rate.Currencies.Contains(calculationParameters.Currency)) ||
                        // check if rate is defined for scheduled periods (if scheduled periods exist at all)
                        (string.IsNullOrEmpty(rate.Periods) &&
                         calculationParameters.ScheduledPeriods != null && calculationParameters.ScheduledPeriods.Count() > 0)
                        ||
                        (!string.IsNullOrEmpty(rate.Periods) &&
                         (calculationParameters.ScheduledPeriods == null || calculationParameters.ScheduledPeriods.Count() == 0))
                        ||
                        (!string.IsNullOrEmpty(rate.Periods) &&
                         calculationParameters.ScheduledPeriods != null && calculationParameters.ScheduledPeriods.Count() > 0 &&
                         rate.Periods.Replace(" ", "").Split(",").Intersect(calculationParameters.ScheduledPeriods.Select(p => p.PeriodType)).Count() == 0))
                    {
                        continue;
                    }
                    if (calculationParameters.Amount.HasValue)
                    {
                        definitionParams.AmountInRuleCurrency = GetAmountInRuleCurrency(rate, calculationParameters.Currency,
                                                                                        calculationParameters.Amount.Value);
                    }

                    var newRate = rate.Copy();
                    newRate = ResolveRateBenefits(calculationParameters, newRate);
                    newRate = ResolveRateOptions(calculationParameters, newRate);

                    if (!string.IsNullOrEmpty(newRate.VariationsDefinitionDMN))
                    {
                        var newVars = await priceCalculationService.ResolveInterestRateVariationDmn(newRate.VariationsDefinitionDMN, definitionParams, newRate.VariationsDefinition);

                        if (newVars != null && newVars.Count > 0)
                        {
                            if (newRate.Variations != null || newRate.Variations.Count > 0)
                            {
                                newRate.Variations = newRate.Variations.Where(nv => nv.Origin != PriceVariationOrigins.Product).ToList();
                            }
                            else
                            {
                                newRate.Variations = new List <InterestRateVariation>();
                            }
                            newRate.Variations.AddRange(newVars);
                        }
                    }
                    if (!string.IsNullOrEmpty(newRate.UpperLimitVariationsDefinitionDMN))
                    {
                        var newVars = await priceCalculationService.ResolveInterestRateVariationDmn(newRate.UpperLimitVariationsDefinitionDMN, definitionParams, newRate.UpperLimitVariationsDefinition);

                        if (newVars != null && newVars.Count > 0)
                        {
                            if (newRate.UpperLimitVariations != null || newRate.UpperLimitVariations.Count > 0)
                            {
                                newRate.UpperLimitVariations = newRate.UpperLimitVariations.Where(nv => nv.Origin != PriceVariationOrigins.Product).ToList();
                            }
                            else
                            {
                                newRate.UpperLimitVariations = new List <InterestRateVariation>();
                            }
                            newRate.UpperLimitVariations.AddRange(newVars);
                        }
                    }
                    if (!string.IsNullOrEmpty(newRate.LowerLimitVariationsDefinitionDMN))
                    {
                        var newVars = await priceCalculationService.ResolveInterestRateVariationDmn(newRate.LowerLimitVariationsDefinitionDMN, definitionParams, newRate.LowerLimitVariationsDefinition);

                        if (newVars != null && newVars.Count > 0)
                        {
                            if (newRate.LowerLimitVariations != null || newRate.LowerLimitVariations.Count > 0)
                            {
                                newRate.LowerLimitVariations = newRate.LowerLimitVariations.Where(nv => nv.Origin != PriceVariationOrigins.Product).ToList();
                            }
                            else
                            {
                                newRate.LowerLimitVariations = new List <InterestRateVariation>();
                            }
                            newRate.LowerLimitVariations.AddRange(newVars);
                        }
                    }

                    var newPrice = GetPrice(newRate, calculationParameters.RequestDate ?? DateTime.Today);
                    if (newPrice != oldCalculatedRate)
                    {
                        result.ResultChanged = true;
                    }

                    var rateWoBundle = GetInterestRateWithoutBundle(newRate, bundleVariationGroup, calculationParameters.RequestDate);
                    if (rateWoBundle > 0)
                    {
                        newRate.RateWithoutBundle = rateWoBundle;
                    }

                    if (newRate.Variations.Any(v => v.Origin == PriceVariationOrigins.SalesDiscount))
                    {
                        newRate.Variations.Reverse();
                    }

                    result.Rates.Add(newRate);
                    if (newRate.Kind == InterestRateKinds.RegularInterest && napr < 0)
                    {
                        napr        = newRate.CalculatedRate;
                        result.Napr = napr;
                    }
                }
            }
            return(result);
        }