Example #1
0
        public async Task <IActionResult> Update([FromBody] TariffDto tariffDto)
        {
            Tariff tariff = await tariffRepository.GetTariff(tariffDto.Id);

            if (tariffDto.TestPeriod.Value != 0)
            {
                TariffTestPeriod testPeriod = new TariffTestPeriod(tariffDto.TestPeriod.Value, (TariffTestPeriodUnit)tariffDto.TestPeriod.Unit);
                tariff.SetTestPeriod(testPeriod);
            }
            else
            {
                tariff.SetTestPeriod(TariffTestPeriod.Empty());
            }
            tariff.SetName(tariffDto.Name);
            tariff.SetArchive(tariffDto.IsArchived);
            tariff.SetAccountingName(tariffDto.AccountingName);
            tariff.SetPaymentType((PaymentType)tariffDto.PaymentType);
            tariff.SetAwaitingPaymentStrategy(tariffDto.AwaitingPaymentStrategy);
            tariff.SetAccountingTariffId(tariffDto.AccountingTariffId);
            tariff.SetSettingsPresetId(tariffDto.SettingsPresetId);
            tariff.SetTermsOfUseId(tariffDto.TermsOfUseId);
            tariff.SetIsAcceptanceRequired(tariffDto.IsAcceptanceRequired);
            tariff.SetIsGradualFinishAvailable(tariff.IsGradualFinishAvailable);

            tariff.RemovePriceItems(tariffDto.Prices.ToTariffPrices());
            tariff.RemoveAdvancePrices(tariffDto.AdvancePrices.ToTariffAdvancePrices());
            tariff.RemoveIncludedProduct(tariffDto.IncludedProducts.Select(x => x.ProductId).ToList());
            tariff.RemoveIncludedProductOption(tariffDto.IncludedProductOptions.Select(x => x.ProductOptionId).ToList());
            tariff.RemoveContractKindBinding(tariffDto.ContractKindBindings.Select(x => x.ContractKindId).ToList());

            //add price
            foreach (var item in tariffDto.Prices)
            {
                Price price = new Price(item.Price.Value, item.Price.Currency);
                ProlongationPeriod period = new ProlongationPeriod(item.Period.Value, (PeriodUnit)item.Period.periodUnit);
                if (tariff.Prices.FirstOrDefault(x => x.Period == period &&
                                                 x.Price.Currency == price.Currency) != null)
                {
                    tariff.ChangePriceItem(price, period);
                }
                else
                {
                    tariff.AddPriceItem(price, period);
                }
            }

            //advancePrice price
            foreach (var item in tariffDto.AdvancePrices)
            {
                Price price = new Price(item.Price.Value, item.Price.Currency);
                ProlongationPeriod period = new ProlongationPeriod(item.Period.Value,
                                                                   (PeriodUnit)item.Period.periodUnit);
                if (tariff.AdvancePrices.FirstOrDefault(x => x.Period == period &&
                                                        x.Price.Currency == price.Currency) != null)
                {
                    tariff.ChangeAdvancePrice(price, period);
                }
                else
                {
                    tariff.AddAdvancePriceItem(price, period);
                }
            }

            //change included product
            foreach (var item in tariffDto.IncludedProducts)
            {
                Product product = await productRepository.GetProduct(item.ProductId);

                if (tariff.IncludedProducts.Select(x => x.ProductId).Contains(item.ProductId))
                {
                    var includedProduct = tariff.IncludedProducts.FirstOrDefault(x => x.ProductId == item.ProductId);
                    tariff.ChangeProduct(includedProduct, product, item.RelativeWeight);
                }
                else
                {
                    tariff.AddProduct(product, item.RelativeWeight);
                }
            }

            //change product option
            foreach (var item in tariffDto.IncludedProductOptions)
            {
                ProductOption productOption = await productOptionRepository.GetProductOption(item.ProductOptionId);

                if (tariff.IncludedProductOptions.Select(x => x.ProductOptionId).Contains(item.ProductOptionId))
                {
                    var includedProductOption = tariff.IncludedProductOptions.FirstOrDefault(x => x.ProductOptionId == item.ProductOptionId);
                    tariff.ChangeProductOption(includedProductOption, productOption, item.Quantity);
                }
                else
                {
                    tariff.AddProductOption(productOption, item.Quantity);
                }
            }

            //change contractKindBindings
            foreach (var item in tariffDto.ContractKindBindings)
            {
                ContractKind contractKind = await contractKindRepository.GetContractKind(item.ContractKindId);

                if (tariff.ContractKindBindings.Select(x => x.ContractKindId).Contains(item.ContractKindId))
                {
                    var contractKindBindings = tariff.ContractKindBindings.FirstOrDefault(x => x.ContractKindId == item.ContractKindId);
                    tariff.ChangeContractKind(contractKindBindings, contractKind);
                }
                else
                {
                    tariff.AddAvailableContractKind(contractKind);
                }
            }

            await tariffRepository.Update(tariff);

            await unitOfWork.SaveEntitiesAsync();

            return(Ok());
        }