public IReadOnlyList <string> CanAddAdvancePriceItem(Price price, ProlongationPeriod period)
{
List <string> errors = new List <string>();
if (price == null)
{
errors.Add(ValidationMessage.MustSpecify("price"));
}
if (period == null)
{
errors.Add(ValidationMessage.MustSpecify("period"));
}
else
{
if (price != null && AdvancePrices.FirstOrDefault(x => x.Period == period &&
x.Price.Currency == price.Currency) !=
null)
{
errors.Add(ValidationMessage.AlreadyExists("prepay price for specified period"));
}
}
return(errors);
}
public TariffPrice(
Price price,
ProlongationPeriod period)
{
Price = new Price(price.Value, price.Currency);
Period = new ProlongationPeriod(period.Value, period.Unit);
}
public async Task <IActionResult> Update([FromBody] ProductOptionTariffDto productOptionTariffDto)
{
ProductOptionTariff productOptionTariff = await productOptionTariffRepository.GetProductOptionTariff(productOptionTariffDto.Id);
if (productOptionTariff == null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"ProductOptionTariff id == {productOptionTariffDto.Id}. Not found!"));
}
productOptionTariff.SetName(productOptionTariffDto.Name);
productOptionTariff.SetProductOption(productOptionTariffDto.ProductOptionId);
productOptionTariff.RemovePriceItems(productOptionTariffDto.Prices.ToProductOptionTariffPrices());
foreach (var item in productOptionTariffDto.Prices)
{
Price price = new Price(item.Price.Value, item.Price.Currency);
ProlongationPeriod period = new ProlongationPeriod(item.Period.Value, (PeriodUnit)item.Period.periodUnit);
if (productOptionTariff.Prices.FirstOrDefault(x => x.Period == period &&
x.Price.Currency == price.Currency) != null)
{
productOptionTariff.ChangePriceItem(price, period);
}
else
{
productOptionTariff.AddPriceItem(price, period);
}
}
await productOptionTariffRepository.Update(productOptionTariff);
await unitOfWork.SaveEntitiesAsync();
return(Ok());
}
public void AddAdvancePriceItem(Price price, ProlongationPeriod period)
{
if (CanAddAdvancePriceItem(price, period).Any())
{
throw new InvalidOperationException();
}
_advancePrices.Add(new TariffAdvancePrice(price, period));
}
public ProductOptionTariffPrice(
int productOptionTariffId,
Price price,
ProlongationPeriod period)
{
ProductOptionTariffId = productOptionTariffId;
Price = price;
Period = period;
}
public void AddPriceItem(Price price, ProlongationPeriod period)
{
if (CanAddPriceItem(price, period).Any())
{
throw new InvalidOperationException();
}
_prices.Add(new ProductOptionTariffPrice(Id, price, period));
}
public void ChangeAdvancePrice(Price price, ProlongationPeriod period)
{
if (CanChangeAdvancePriceItem(price, period).Any())
{
throw new InvalidOperationException();
}
var index = _advancePrices.FindIndex(x => x.Period == period && x.Price.Currency == price.Currency);
_advancePrices[index].SetPrice(price);
_advancePrices[index].SetPeriod(period);
}
public TariffAdvancePrice(
Price price,
ProlongationPeriod period)
{
if (price == null || price.Value <= 0)
{
throw new ArgumentException("The price cannot be null and must be greater than zero.");
}
Price = new Price(price.Value, price.Currency);
Period = new ProlongationPeriod(period.Value, period.Unit);
}
/// <summary>
/// Абонентская плата за период
/// </summary>
/// <param name="prolongationPeriod"></param>
/// <param name="currency"></param>
/// <returns></returns>
public Price GetFeeForThePeriod(ProlongationPeriod prolongationPeriod, string currency)
{
switch (PaymentType)
{
case PaymentType.Prepaid:
case PaymentType.Postpaid:
return(GetPrice(prolongationPeriod, currency));
case PaymentType.Commission:
return(new Price(0, currency));
default:
throw new InvalidOperationException();
}
}
public static ProlongationPeriodDto Map(this ProlongationPeriod prolongationPeriod)
{
if (prolongationPeriod == null)
{
return(null);
}
else
{
return(new ProlongationPeriodDto
{
Value = prolongationPeriod.Value,
periodUnit = (int)prolongationPeriod.Unit
});
}
}
public IReadOnlyList <string> CanChangePriceItem(Price price, ProlongationPeriod period)
{
List <string> errors = new List <string>();
if (price == null)
{
errors.Add(ValidationMessage.MustSpecify("price"));
}
if (period == null)
{
errors.Add(ValidationMessage.MustSpecify("period"));
}
return(errors);
}
public async Task <IActionResult> Add([FromBody] ProductOptionTariffDto productOptionTariffDto)
{
ProductOptionTariff productOptionTariff = new ProductOptionTariff(
productOptionTariffDto.ProductOptionId,
productOptionTariffDto.Name);
foreach (var priceItem in productOptionTariffDto.Prices)
{
Price price = new Price(priceItem.Price.Value, priceItem.Price.Currency);
ProlongationPeriod prolongationPeriod = new ProlongationPeriod(priceItem.Period.Value, (PeriodUnit)priceItem.Period.periodUnit);
productOptionTariff.AddPriceItem(price, prolongationPeriod);
}
await productOptionTariffRepository.Add(productOptionTariff);
await unitOfWork.SaveEntitiesAsync();
return(Ok());
}
/// <summary>
/// Сумма аванса по тарифу
/// </summary>
public Price GetAdvancePrice(ProlongationPeriod prolongationPeriod, string currency)
{
return(AdvancePrices.FirstOrDefault(x => x.Period == prolongationPeriod &&
x.Price.Currency == currency)?.Price);
}
public void SetPeriod(ProlongationPeriod period)
{
Period = period;
}
public async Task <IActionResult> Add([FromBody] TariffDto tariffDto)
{
Tariff tariff = new Tariff(tariffDto.Name, (PaymentType)tariffDto.PaymentType);
if (tariffDto.TestPeriod.Value != 0)
{
TariffTestPeriod testPeriod = new TariffTestPeriod(tariffDto.TestPeriod.Value, (TariffTestPeriodUnit)tariffDto.TestPeriod.Unit);
tariff.AddTestPeriod(testPeriod);
}
tariff.SetArchive(tariffDto.IsArchived);
tariff.SetAccountingTariffId(tariffDto.AccountingName);
tariff.SetAwaitingPaymentStrategy(tariffDto.AwaitingPaymentStrategy);
tariff.SetSettingsPresetId(tariffDto.SettingsPresetId);
tariff.SetTermsOfUseId(tariffDto.TermsOfUseId);
tariff.SetIsAcceptanceRequired(tariffDto.IsAcceptanceRequired);
tariff.SetIsGradualFinishAvailable(tariffDto.IsGradualFinishAvailable);
//add price
foreach (var tariffPrice in tariffDto.Prices)
{
Price price = new Price(tariffPrice.Price.Value, tariffPrice.Price.Currency);
ProlongationPeriod period = new ProlongationPeriod(tariffPrice.Period.Value, (PeriodUnit)tariffPrice.Period.periodUnit);
tariff.AddPriceItem(price, period);
}
foreach (var advancePrice in tariffDto.AdvancePrices)
{
Price price = new Price(advancePrice.Price.Value, advancePrice.Price.Currency);
ProlongationPeriod period = new ProlongationPeriod(advancePrice.Period.Value, (PeriodUnit)advancePrice.Period.periodUnit);
tariff.AddAdvancePriceItem(price, period);
}
//add included product
foreach (var includedProduct in tariffDto.IncludedProducts)
{
Product product = await productRepository.GetProduct(includedProduct.ProductId);
tariff.AddProduct(product, includedProduct.RelativeWeight);
}
//add product option
foreach (var includedProductOption in tariffDto.IncludedProductOptions)
{
ProductOption productOption = await productOptionRepository.GetProductOption(includedProductOption.ProductOptionId);
tariff.AddProductOption(productOption, includedProductOption.Quantity);
}
//add contractKindBindings
foreach (var contractKindBinding in tariffDto.ContractKindBindings)
{
ContractKind contractkind = await contractKindRepository.GetContractKind(contractKindBinding.ContractKindId);
tariff.AddAvailableContractKind(contractkind);
}
await tariffRepository.Add(tariff);
await unitOfWork.SaveEntitiesAsync();
return(Ok());
}
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());
}
