/// <inheritdoc />
public async Task <TariffDto> Create(TariffDto request)
{
var domain = _mapper.ToEntity(request);
using (var db = new ApplicationDbContext())
{
var result = await db.Tariffs.AddAsync(domain);
await db.SaveChangesAsync();
return(_mapper.ToDto(result.Entity));
}
}
public Tariff MapToTariff(TariffDto tariffDto)
{
return(new Tariff
{
Id = tariffDto.Id,
Amount = tariffDto.Amount,
IsActive = tariffDto.IsActive,
Energy = tariffDto.Energy,
EnergyIn = tariffDto.EnergyIn,
Name = tariffDto.Name,
Unit = tariffDto.Unit,
CreateDate = tariffDto.CreateDate,
ModifiedDate = tariffDto.ModifiedDate,
IsDeleted = tariffDto.IsDeleted
});
}
public async Task <bool> Delete(TariffDto input)
{
var items = UnitOfWork.TariffItemRepository.GetAllWithTariffId(input.Id);
var prices = UnitOfWork.TariffPriceRepository.GetAllWithTariffId(input.Id);
foreach (var item in items)
{
UnitOfWork.TariffItemRepository.DeleteLogically(item);
}
foreach (var price in prices)
{
UnitOfWork.TariffPriceRepository.DeleteLogically(price);
}
UnitOfWork.TariffRepository.DeleteLogically(input.Id);
await UnitOfWork.SaveAsync();
return(true);
}
public TariffDto MapToTariffDto(Tariff tariff)
{
if (tariff != null)
{
var tariffDto = new TariffDto
{
Id = tariff.Id,
Amount = tariff.Amount,
IsActive = tariff.IsActive,
Energy = tariff.Energy,
EnergyIn = tariff.EnergyIn,
Name = tariff.Name,
Unit = tariff.Unit,
CreateDate = tariff.CreateDate,
ModifiedDate = tariff.ModifiedDate,
IsDeleted = tariff.IsDeleted
};
return(tariffDto);
}
return(new TariffDto());
}
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());
}
public async Task <JsonResult> Tariff([FromBody] TariffDto request)
{
var result = await _service.Create(request);
return(Json(result));
}
