Пример #1
0
        /// <summary>
        /// Оплата доставки 6л бутылей
        /// </summary>
        decimal CalculateWageFor6LBottles(IRouteListItemWageCalculationSource src)
        {
            var     rate          = GetActualRate(WageRateTypes.Bottle6L);
            decimal paymentForOne = GetRateValue(src, rate);

            return(paymentForOne * src.Bottle6LCount);
        }
        public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            decimal resultSum = 0;

            if (!src.IsValidForWageCalculation || !Car.GetCarTypesOfUseForRatesLevelWageCalculation().Contains(src.CarTypeOfUse))
            {
                return(new RouteListItemWageResult(0, GetCurrentWageDistrictLevelRate(src)));
            }

            #region Оплата оборудования, если нет 19л воды в заказе
            var wageForBottlesOrEquipment = CalculateWageForFull19LBottles(src);
            if (wageForBottlesOrEquipment <= 0)
            {
                wageForBottlesOrEquipment = CalculateWageForEquipment(src);
            }
            #endregion Оплата оборудования, если нет 19л воды в заказе

            resultSum += CalculateWageForAddress(src);
            resultSum += wageForBottlesOrEquipment;
            resultSum += CalculateWageForEmpty19LBottles(src);
            resultSum += CalculateWageFor600mlBottles(src);
            resultSum += CalculateWageFor6LBottles(src);
            resultSum += CalculateWageFor1500mlBottles(src);
            resultSum += CalculateWageFor500mlBottles(src);
            resultSum += CalculateWageForFastDelivery(src);

            return(new RouteListItemWageResult(
                       resultSum,
                       GetCurrentWageDistrictLevelRate(src)
                       ));
        }
Пример #3
0
        public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            decimal resultSum = 0;

            if (!src.IsDelivered)
            {
                return(new RouteListItemWageResult(0));
            }

            if (source.IsTruck)
            {
                return(new RouteListItemWageResult(0));
            }

            #region Оплата оборудования, если нет 19л воды в заказе
            var wageForBottlesOrEquipment = CalculateWageForFull19LBottles(src);
            if (wageForBottlesOrEquipment <= 0)
            {
                wageForBottlesOrEquipment = CalculateWageForEquipment(src);
            }
            #endregion Оплата оборудования, если нет 19л воды в заказе

            resultSum += CalculateWageForAddress(src);
            resultSum += wageForBottlesOrEquipment;
            resultSum += CalculateWageForEmpty19LBottles(src);
            resultSum += CalculateWageFor600mlBottles(src);
            resultSum += CalculateWageFor6LBottles(src);

            return(new RouteListItemWageResult(
                       resultSum
                       ));
        }
Пример #4
0
        /// <summary>
        /// Оплата 0.6л бутылей
        /// </summary>
        decimal CalculateWageFor600mlBottles(IRouteListItemWageCalculationSource src)
        {
            var     rate = GetActualRate(WageRateTypes.PackOfBottles600ml);
            decimal paymentForOnePack = GetRateValue(src, rate);

            return(Math.Truncate(paymentForOnePack / 36 * src.Bottle600mlCount));
        }
        /// <summary>
        /// Оплата 0.6л бутылей
        /// </summary>
        decimal CalculateWageFor600mlBottles(IRouteListItemWageCalculationSource src)
        {
            var rate = GetCurrentWageDistrictLevelRate(src).WageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.PackOfBottles600ml);

            decimal paymentForOnePack = GetRateValue(src, rate);

            return(Math.Truncate(paymentForOnePack / 36 * src.Bottle600mlCount));
        }
Пример #6
0
        /// <summary>
        /// Оплата забора пустых бутылей
        /// </summary>
        decimal CalculateWageForEmpty19LBottles(IRouteListItemWageCalculationSource src)
        {
            bool addressWithBigOrder = HasBigOrder(src);

            var     rate          = GetActualRate(addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder : WageRateTypes.EmptyBottle19L);
            decimal paymentForOne = GetRateValue(src, rate);

            return(paymentForOne * src.EmptyBottle19LCount);
        }
        /// <summary>
        /// Оплата доставки 0,5л бутылей
        /// </summary>
        decimal CalculateWageFor500mlBottles(IRouteListItemWageCalculationSource src)
        {
            WageDistrictLevelRate wageCalcMethodic = GetCurrentWageDistrictLevelRate(src);

            var rate = wageCalcMethodic.WageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Bottle500ml);

            decimal paymentForOne = GetRateValue(src, rate);

            return(paymentForOne * src.Bottle500mlCount);
        }
        /// <summary>
        /// Оплата адреса
        /// </summary>
        decimal CalculateWageForAddress(IRouteListItemWageCalculationSource src)
        {
            if (!src.HasFirstOrderForDeliveryPoint)
            {
                return(0);
            }

            var rate = GetCurrentWageDistrictLevelRate(src).WageRates.FirstOrDefault(r => r.WageRateType == (src.IsDriverForeignDistrict? WageRateTypes.ForeignAddress : WageRateTypes.Address));

            return(GetRateValue(src, rate));
        }
Пример #9
0
        /// <summary>
        /// Оплата адреса
        /// </summary>
        decimal CalculateWageForAddress(IRouteListItemWageCalculationSource src)
        {
            if (!src.HasFirstOrderForDeliveryPoint)
            {
                return(0);
            }

            var rate = GetActualRate(WageRateTypes.Address);

            return(GetRateValue(src, rate));
        }
Пример #10
0
        /// <summary>
        /// Оплата забор-доставки оборудования
        /// </summary>
        decimal CalculateWageForEquipment(IRouteListItemWageCalculationSource src)
        {
            if (!src.NeedTakeOrDeliverEquipment)
            {
                return(0);
            }

            var rate = GetActualRate(WageRateTypes.Equipment);

            return(GetRateValue(src, rate));
        }
        /// <summary>
        /// Оплата забор-доставки оборудования
        /// </summary>
        decimal CalculateWageForEquipment(IRouteListItemWageCalculationSource src)
        {
            if (!src.NeedTakeOrDeliverEquipment)
            {
                return(0);
            }

            var rate = GetCurrentWageDistrictLevelRate(src).WageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Equipment);

            return(GetRateValue(src, rate));
        }
        /// <summary>
        /// Оплата доставки за час
        /// </summary>
        decimal CalculateWageForFastDelivery(IRouteListItemWageCalculationSource src)
        {
            if (!src.IsFastDelivery)
            {
                return(0);
            }

            WageDistrictLevelRate wageCalcMethodic = GetCurrentWageDistrictLevelRate(src);

            var rate = wageCalcMethodic.WageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.FastDelivery);

            return(GetRateValue(src, rate));
        }
Пример #13
0
        private decimal GetRateValue(IRouteListItemWageCalculationSource itemSource, WageRate rate)
        {
            switch (source.EmployeeCategory)
            {
            case EmployeeCategory.driver:
                return(itemSource.WasVisitedByForwarder ? rate.ForDriverWithForwarder : rate.ForDriverWithoutForwarder);

            case EmployeeCategory.forwarder:
                return(rate.ForForwarder);

            case EmployeeCategory.office:
            default:
                throw new InvalidOperationException($"Для указанного типа сотрудника \"{source.EmployeeCategory.GetEnumTitle()}\" не предусмотрен расчет зарплаты");
            }
        }
        /// <summary>
        /// Оплата забора пустых бутылей
        /// </summary>
        decimal CalculateWageForEmpty19LBottles(IRouteListItemWageCalculationSource src)
        {
            bool addressWithBigOrder = HasBigOrder(src);

            var rate = GetCurrentWageDistrictLevelRate(src).WageRates
                       .FirstOrDefault(
                r => r.WageRateType == (
                    addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder : WageRateTypes.EmptyBottle19L
                    )
                );

            decimal paymentForOne = GetRateValue(src, rate);

            return(paymentForOne * src.EmptyBottle19LCount);
        }
        private decimal GetRateValue(IRouteListItemWageCalculationSource src, WageRate rate)
        {
            if (rate == null)
            {
                return(0);
            }
            switch (wageCalculationSource.EmployeeCategory)
            {
            case EmployeeCategory.driver:
                return(src.WasVisitedByForwarder ? rate.WageForDriverWithForwarder(src): rate.WageForDriverWithoutForwarder(src));

            case EmployeeCategory.forwarder:
                return(rate.WageForForwarder(src));

            case EmployeeCategory.office:
            default:
                throw new InvalidOperationException($"Для указанного типа сотрудника \"{wageCalculationSource.EmployeeCategory.GetEnumTitle()}\" не предусмотрен расчет зарплаты по уровням");
            }
        }
        public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            switch (wageParameterItem.PercentWageType)
            {
            case PercentWageTypes.RouteList:
                var itemsSum    = src.OrderItemsSource.Sum(i => (i.ActualCount ?? i.InitialCount) * i.Price - i.DiscountMoney);
                var depositsSum = src.OrderDepositItemsSource.Sum(d => (d.ActualCount ?? d.InitialCount) * d.Deposit);
                return(new RouteListItemWageResult(
                           (itemsSum - depositsSum) * wageParameterItem.RouteListPercent / 100
                           ));

            case PercentWageTypes.Service:
                var wageForService = src.OrderItemsSource
                                     .Where(i => i.IsMasterNomenclature && i.ActualCount.HasValue)
                                     .Sum(i => i.ActualCount.Value * i.Price * i.PercentForMaster / 100);
                return(new RouteListItemWageResult(wageForService));

            default:
                throw new NotImplementedException();
            }
        }
 public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource source) => new RouteListItemWageResult();
 public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource source)
 {
     return(calculationService.GetWageCalculationDetailsForRouteListItem(source));
 }
Пример #19
0
        /// <summary>
        /// Большой ли заказ
        /// </summary>
        bool HasBigOrder(IRouteListItemWageCalculationSource src)
        {
            var rate = GetActualRate(WageRateTypes.MinBottlesQtyInBigOrder);

            return(src.FullBottle19LCount >= (GetRateValue(src, rate)));
        }
 /// <summary>
 /// Возврат текущей методики расчёта ЗП. Берёться значение либо
 /// актуальное из сотрудника, в случае первого расчёта, либо из
 /// сохранённого в уже посчитанном адресе МЛ
 /// </summary>
 WageDistrictLevelRate GetCurrentWageDistrictLevelRate(IRouteListItemWageCalculationSource src)
 {
     return(src.WageCalculationMethodic
            ?? wageParameterItem.WageDistrictLevelRates.LevelRates
            .FirstOrDefault(r => r.WageDistrict == src.WageDistrictOfAddress && r.CarTypeOfUse == src.CarTypeOfUse));
 }
Пример #21
0
        public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource source)
        {
            RouteListItemWageCalculationDetails addressWageDetails = new RouteListItemWageCalculationDetails()
            {
                RouteListItemWageCalculationName = wageParameterItem.Title,
                WageCalculationEmployeeCategory  = source.EmployeeCategory
            };

            return(addressWageDetails);
        }
 public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource source)
 {
     return(calculationService.CalculateWageForRouteListItem(source));
 }
        public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            var levelRate          = GetCurrentWageDistrictLevelRate(src);
            var addressWageDetails = new RouteListItemWageCalculationDetails
            {
                RouteListItemWageCalculationName = $"{WageParameterItemTypes.RatesLevel.GetEnumTitle()}, {levelRate.WageDistrictLevelRates.Name} №{levelRate.WageDistrictLevelRates.Id}. ",
                WageCalculationEmployeeCategory  = src.EmployeeCategory
            };

            if (!src.IsValidForWageCalculation || !Car.GetCarTypesOfUseForRatesLevelWageCalculation().Contains(src.CarTypeOfUse))
            {
                return(addressWageDetails);
            }

            IList <WageRate> wageRates = GetCurrentWageDistrictLevelRate(src).WageRates;

            if (!src.HasFirstOrderForDeliveryPoint)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name = $"Не первый заказ на точку доставки",
                });
            }
            else
            {
                var rateAddress = wageRates.FirstOrDefault(r =>
                                                           r.WageRateType == (src.IsDriverForeignDistrict ? WageRateTypes.ForeignAddress : WageRateTypes.Address));
                if (rateAddress != null)
                {
                    addressWageDetails.WageCalculationDetailsList.Add(
                        new WageCalculationDetailsItem()
                    {
                        Name  = $"{rateAddress.WageRateType.GetEnumTitle()}",
                        Count = 1,
                        Price = GetRateValue(src, rateAddress)
                    });
                }
            }

            bool addressWithBigOrder = HasBigOrder(src);
            var  rateFullBottle19L   = wageRates
                                       .FirstOrDefault(r => r.WageRateType == (addressWithBigOrder ? WageRateTypes.Bottle19LInBigOrder : WageRateTypes.Bottle19L));
            var priceFullBottle19L = GetRateValue(src, rateFullBottle19L);

            if (priceFullBottle19L * src.FullBottle19LCount > 0)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name  = rateFullBottle19L.WageRateType.GetEnumTitle(),
                    Count = src.FullBottle19LCount,
                    Price = priceFullBottle19L
                });
            }
            else
            {
                if (src.NeedTakeOrDeliverEquipment)
                {
                    addressWageDetails.WageCalculationDetailsList.Add(
                        new WageCalculationDetailsItem()
                    {
                        Name  = WageRateTypes.Equipment.GetEnumTitle(),
                        Count = 1,
                        Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Equipment))
                    });
                }
            }

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder.GetEnumTitle() : WageRateTypes.EmptyBottle19L.GetEnumTitle(),
                Count = src.EmptyBottle19LCount,
                Price = GetRateValue(src,
                                     wageRates
                                     .FirstOrDefault(r => r.WageRateType == (addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder : WageRateTypes.EmptyBottle19L))
                                     )
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.PackOfBottles600ml.GetEnumTitle(),
                Count = src.Bottle600mlCount,
                Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.PackOfBottles600ml)) / 36
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.Bottle6L.GetEnumTitle(),
                Count = src.Bottle6LCount,
                Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Bottle6L))
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.Bottle1500ml.GetEnumTitle(),
                Count = src.Bottle1500mlCount,
                Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Bottle1500ml))
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.Bottle500ml.GetEnumTitle(),
                Count = src.Bottle500mlCount,
                Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.Bottle500ml))
            });

            if (src.IsFastDelivery)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name  = WageRateTypes.FastDelivery.GetEnumTitle(),
                    Count = 1,
                    Price = GetRateValue(src, wageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.FastDelivery))
                });
            }

            return(addressWageDetails);
        }
        public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource source)
        {
            RouteListItemWageCalculationDetails addressWageDetails = new RouteListItemWageCalculationDetails()
            {
                RouteListItemWageCalculationName = "Способ расчёта ЗП по умолчанию",
                WageCalculationEmployeeCategory  = source.EmployeeCategory
            };

            return(addressWageDetails);
        }
Пример #25
0
 public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource source)
 {
     return(new RouteListItemWageResult(source.CurrentWage, source.WageCalculationMethodic));
 }
 public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource source)
 {
     throw new InvalidOperationException("Нельзя получить детализацию расчёта ЗП за один адрес при типе расчёта за весь МЛ по фиксированной ставке");
 }
        /// <summary>
        /// Большой ли заказ
        /// </summary>
        bool HasBigOrder(IRouteListItemWageCalculationSource src)
        {
            var rate = GetCurrentWageDistrictLevelRate(src).WageRates.FirstOrDefault(r => r.WageRateType == WageRateTypes.MinBottlesQtyInBigOrder);

            return(src.FullBottle19LCount >= GetRateValue(src, rate));
        }
Пример #28
0
 public RouteListItemWageResult CalculateWageForRouteListItem(IRouteListItemWageCalculationSource source)
 {
     return(new RouteListItemWageResult());
 }
        public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            RouteListItemWageCalculationDetails addressWageDetails = new RouteListItemWageCalculationDetails()
            {
                RouteListItemWageCalculationName = wageParameterItem.Title,
                WageCalculationEmployeeCategory  = src.EmployeeCategory
            };

            switch (wageParameterItem.PercentWageType)
            {
            case PercentWageTypes.RouteList:
                var itemsSum    = src.OrderItemsSource.Sum(i => (i.ActualCount ?? i.InitialCount) * i.Price - i.DiscountMoney);
                var depositsSum = src.OrderDepositItemsSource.Sum(d => (d.ActualCount ?? d.InitialCount) * d.Deposit);
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name  = PercentWageTypes.RouteList.GetEnumTitle(),
                    Count = 1,
                    Price = (itemsSum - depositsSum) * wageParameterItem.RouteListPercent / 100
                });
                break;

            case PercentWageTypes.Service:
                var wageForService = src.OrderItemsSource
                                     .Where(i => i.IsMasterNomenclature && i.ActualCount.HasValue)
                                     .Sum(i => i.ActualCount.Value * i.Price * i.PercentForMaster / 100);
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name  = PercentWageTypes.Service.GetEnumTitle(),
                    Count = 1,
                    Price = wageForService
                });
                break;
            }

            return(addressWageDetails);
        }
Пример #30
0
        public RouteListItemWageCalculationDetails GetWageCalculationDetailsForRouteListItem(IRouteListItemWageCalculationSource src)
        {
            RouteListItemWageCalculationDetails addressWageDetails = new RouteListItemWageCalculationDetails()
            {
                RouteListItemWageCalculationName = wageParameterItem.Title,
                WageCalculationEmployeeCategory  = source.EmployeeCategory
            };

            if (!src.IsDelivered)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name = $"Заказ не доставлен",
                });
                return(addressWageDetails);
            }

            if (source.IsTruck)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name = $"ТС является фурой",
                });
                return(addressWageDetails);
            }

            if (!src.HasFirstOrderForDeliveryPoint)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name = $"Не первый заказ на точку доставки",
                });
            }
            else
            {
                var rateAddress = GetActualRate(src.IsDriverForeignDistrict ? WageRateTypes.ForeignAddress : WageRateTypes.Address);
                if (rateAddress != null)
                {
                    addressWageDetails.WageCalculationDetailsList.Add(
                        new WageCalculationDetailsItem()
                    {
                        Name  = $"{rateAddress.WageRateType.GetEnumTitle()}",
                        Count = 1,
                        Price = GetRateValue(src, rateAddress)
                    });
                }
            }

            bool addressWithBigOrder = HasBigOrder(src);
            var  rateFullBottle19L   = GetActualRate(addressWithBigOrder ? WageRateTypes.Bottle19LInBigOrder : WageRateTypes.Bottle19L);
            var  priceFullBottle19L  = GetRateValue(src, rateFullBottle19L);

            if (priceFullBottle19L * src.FullBottle19LCount > 0)
            {
                addressWageDetails.WageCalculationDetailsList.Add(
                    new WageCalculationDetailsItem()
                {
                    Name  = rateFullBottle19L.WageRateType.GetEnumTitle(),
                    Count = src.FullBottle19LCount,
                    Price = priceFullBottle19L
                });
            }
            else
            {
                if (src.NeedTakeOrDeliverEquipment)
                {
                    addressWageDetails.WageCalculationDetailsList.Add(
                        new WageCalculationDetailsItem()
                    {
                        Name  = WageRateTypes.Equipment.GetEnumTitle(),
                        Count = 1,
                        Price = GetRateValue(src, GetActualRate(WageRateTypes.Equipment)
                                             )
                    });
                }
            }

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder.GetEnumTitle() : WageRateTypes.EmptyBottle19L.GetEnumTitle(),
                Count = src.EmptyBottle19LCount,
                Price = GetRateValue(src, GetActualRate(addressWithBigOrder ? WageRateTypes.EmptyBottle19LInBigOrder : WageRateTypes.EmptyBottle19L)
                                     )
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.PackOfBottles600ml.GetEnumTitle(),
                Count = src.Bottle600mlCount,
                Price = GetRateValue(src, GetActualRate(WageRateTypes.PackOfBottles600ml)) / 36
            });

            addressWageDetails.WageCalculationDetailsList.Add(
                new WageCalculationDetailsItem()
            {
                Name  = WageRateTypes.Bottle6L.GetEnumTitle(),
                Count = src.Bottle6LCount,
                Price = GetRateValue(src, GetActualRate(WageRateTypes.Bottle6L)
                                     )
            });

            return(addressWageDetails);
        }