public BasketRecordModel Apply(BasketRecordEntity record, DiscountEntity entity)
{
var discountAmount = record.Product.Price * entity.Percentage / 100;
record.Product.Price -= discountAmount;
return(new BasketRecordModel(record.Count, new ProductModel(record.Product.Price)));
}
public static Discount ToCoreModel(this DiscountEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var retVal = new Discount();
retVal.InjectFrom(entity);
if (entity.Currency != null)
{
retVal.Currency = (CurrencyCodes)Enum.Parse(typeof(CurrencyCodes), entity.Currency);
}
if (entity.CouponCode != null)
{
retVal.Coupon = new Coupon
{
Code = entity.CouponCode,
InvalidDescription = entity.CouponInvalidDescription,
};
}
return(retVal);
}
public void BuyTwoGetOneFree(decimal price, int count, int expectedCount, decimal expectedPrice)
{
var product = new ProductEntity {
Price = price
};
var record = new BasketRecordEntity {
Count = count, Product = product
};
var basket = new BasketEntity
{
Records = new[] { record }
};
var percentageDiscount = new DiscountEntity
{
Type = DiscountEntityType.BuyTwoGetOneForFree,
TargetProduct = product,
RewardProduct = product,
};
var dbPrice = _sut.CalculatePrice(basket);
var basketModel = _sut.CalculatePriceWithDiscounts(basket, new[] { percentageDiscount });
var basketModelPrice = _sut.CalculatePrice(basketModel);
var basketModelProductCount = basketModel.Records[0].Count + basketModel.Records[0].FreeProducts.Count;
dbPrice.Should().Be(price * record.Count);
basketModelPrice.Should().Be(expectedPrice);
basketModelProductCount.Should().Be(expectedCount);
}
public void Percentage(decimal price, decimal percentage, decimal expected)
{
var product = new ProductEntity {
Price = price
};
var record = new BasketRecordEntity {
Count = 1, Product = product
};
var basket = new BasketEntity
{
Records = new[] { record }
};
var percentageDiscount = new DiscountEntity
{
Type = DiscountEntityType.Percentage,
Percentage = percentage,
TargetProduct = product
};
var dbPrice = _sut.CalculatePrice(basket);
var basketModel = _sut.CalculatePriceWithDiscounts(basket, new[] { percentageDiscount });
var basketModelPrice = _sut.CalculatePrice(basketModel);
dbPrice.Should().Be(price);
basketModelPrice.Should().Be(expected);
}
/// <summary>
/// Patch CatalogBase type
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Patch(this DiscountEntity source, DiscountEntity target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
}
public DiscountEntity Update(EmployeeEntity EmployeeEntity, Guid DiscountId, DiscountEntity DiscountEntity)
{
Discount Discount = UnitOfWork.DiscountRepository.Get(DiscountId);
DiscountEntity.Id = DiscountId;
Discount = new Discount(DiscountEntity);
UnitOfWork.DiscountRepository.AddOrUpdate(Discount);
UnitOfWork.Complete();
return(Get(EmployeeEntity, Discount.Id));
}
public BasketRecordModel Apply(BasketRecordEntity record, DiscountEntity entity)
{
var recordModel = new BasketRecordModel(record.Count, new ProductModel(record.Product.Price));
var amountOfItemsToDiscount = (int)Math.Floor(record.Count / 2f);
for (int i = 0; i < amountOfItemsToDiscount; i++)
{
recordModel.FreeProducts.Add(new ProductModel(entity.RewardProduct.Price));
}
return(recordModel);
}
public DiscountEntity Create(EmployeeEntity EmployeeEntity, DiscountEntity DiscountEntity)
{
if (DiscountEntity == null)
{
throw new NotFoundException();
}
Discount Discount = new Discount(DiscountEntity);
UnitOfWork.DiscountRepository.AddOrUpdate(Discount);
UnitOfWork.Complete();
return(Get(EmployeeEntity, Discount.Id));
}
public DiscountEntity Update(DiscountEntity entity)
{
try
{
_discountRepository.Update(entity);
return(entity);
}
catch (Exception e)
{
_log.Error(e, "数据库操作出错");
return(null);
}
}
public bool Delete(DiscountEntity entity)
{
try
{
_discountRepository.Delete(entity);
return(true);
}
catch (Exception e)
{
_log.Error(e, "数据库操作出错");
return(false);
}
}
private List <DiscountEntity> GenerateDiscountData(List <OIDetails> OIdata, List <CompanyDetails> Basicdata)
{
List <DiscountEntity> discountList = new List <DiscountEntity>();
DiscountEntity objitem = null;
foreach (var oIItem in OIdata.Where(x => x.CompanyCode != null))
{
objitem = new DiscountEntity();
var basicItem = Basicdata.Where(x => x.Code == oIItem.CompanyCode).ToList();
if (basicItem.Count > 0)
{
objitem.CompanyCode = oIItem.CompanyCode;
objitem.IOLtp = oIItem.LastPrice;
objitem.IOPreviousClose = oIItem.PrevClose;
objitem.IOOpenPrice = oIItem.OpenPrice;
objitem.IOLowPrice = oIItem.LowPrice;
objitem.IOHighPrice = (oIItem.HighPrice.Split('}'))[0].Replace("\"", "");
objitem.IOPercentChange = oIItem.PChange;
objitem.IOClosed = oIItem.Closed;
objitem.BasicLtp = basicItem[0].lastPrice;
objitem.BasicPreviousClose = basicItem[0].PreClose;
objitem.BasicOpenPrice = basicItem[0].Open;
objitem.BasicLowPrice = basicItem[0].Low;
objitem.BasicHighPrice = basicItem[0].High;
objitem.BasicPercentChange = basicItem[0].pChange;
objitem.BasicClosed = basicItem[0].Closed;
Decimal DiscountPrice = 0;
if (objitem.IOPercentChange != "-" && objitem.BasicPercentChange != "-")
{
if (objitem.IOClosed != null && objitem.IOClosed != "" && objitem.BasicClosed != null && objitem.BasicClosed != "")
{
DiscountPrice = ((Convert.ToDecimal(objitem.IOClosed) - Convert.ToDecimal(objitem.BasicClosed)) / Math.Abs(Convert.ToDecimal(objitem.BasicClosed))) * 100;
objitem.DiscountPrice = Convert.ToString(Math.Round(DiscountPrice, 2));
}
else if (objitem.IOLtp != null && objitem.IOLtp != "" && objitem.BasicLtp != null && objitem.BasicLtp != "")
{
DiscountPrice = ((Convert.ToDecimal(objitem.IOLtp) - Convert.ToDecimal(objitem.BasicLtp)) / Math.Abs(Convert.ToDecimal(objitem.BasicLtp))) * 100;
objitem.DiscountPrice = Convert.ToString(Math.Round(DiscountPrice, 2));
}
}
discountList.Add(objitem);
}
}
return(discountList.OrderByDescending(x => Convert.ToDecimal(x.DiscountPrice)).ToList());
}
public static DiscountEntity CreateDiscount(int accountId, DateTime startDate, DateTime endDate, decimal percent, string description = null, DiscountType discountType = DiscountType.PersonalAccount)
{
var discount = new DiscountEntity
{
AccountId = accountId,
StartDate = startDate,
EndDate = endDate,
Percent = percent,
Description = description,
Type = DiscountType.PersonalAccount
};
return(discount);
}
public bool Delete(Guid Id)
{
bool toReturn = false;
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
DiscountEntity _DiscountEntity = new DiscountEntity(Id);
if (adapter.FetchEntity(_DiscountEntity))
{
adapter.DeleteEntity(_DiscountEntity);
toReturn = true;
}
}
return toReturn;
}
public bool AddDiscount(int storeId, DiscountDto discountDto)
{
try
{
DiscountEntity discountEntity = new DiscountEntity
{
Amount = discountDto.Amount, IsPercentage = discountDto.IsPercentage,
StoreId = storeId, DiscountName = discountDto.DiscountName
};
_context.Discounts.Add(discountEntity);
_context.SaveChanges();
return(true);
}catch
{
return(false);
}
}
public static DiscountEntity ToDataModel(this coreModel.Discount discount, PrimaryKeyResolvingMap pkMap)
{
if (discount == null)
{
throw new ArgumentNullException("discount");
}
var retVal = new DiscountEntity();
pkMap.AddPair(discount, retVal);
retVal.InjectFrom(discount);
retVal.Currency = discount.Currency.ToString();
retVal.CouponCode = discount.Coupon;
return(retVal);
}
public static coreModel.Discount ToCoreModel(this DiscountEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var retVal = new coreModel.Discount();
retVal.InjectFrom(entity);
retVal.Coupon = entity.CouponCode;
if (entity.Currency != null)
{
retVal.Currency = (CurrencyCodes)Enum.Parse(typeof(CurrencyCodes), entity.Currency);
}
return(retVal);
}
public void SendDiscountToArchiveTest()
{
var account = Seed.SeedData().AccountEntity;
var discount = new DiscountEntity()
{
AccountId = account.Id,
IsArchive = false
};
const bool expected = true;
using (var scope = _container.BeginLifetimeScope())
{
var discountService = scope.Resolve <IDiscountDocumentService>();
discountService.Add(discount);
discountService.SendToArchive(discount);
var actual = discountService.GetItemById(discount.Id);
Assert.AreEqual(expected, actual.IsArchive);
}
}
public static DiscountEntity ToDataModel(this Discount discount)
{
if (discount == null)
{
throw new ArgumentNullException("discount");
}
var retVal = new DiscountEntity();
retVal.InjectFrom(discount);
if (discount.Currency != null)
{
retVal.Currency = discount.Currency.ToString();
}
if (discount.Coupon != null)
{
retVal.CouponCode = discount.Coupon.Code;
retVal.CouponInvalidDescription = discount.Coupon.InvalidDescription;
}
return(retVal);
}
public bool Update(Guid Id, string DiscountName, double PercentAmount, long IsActive)
{
bool toReturn = false;
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
DiscountEntity _DiscountEntity = new DiscountEntity(Id);
if (adapter.FetchEntity(_DiscountEntity))
{
_DiscountEntity.DiscountName = DiscountName;
_DiscountEntity.PercentAmount = PercentAmount;
_DiscountEntity.IsActive = IsActive;
adapter.SaveEntity(_DiscountEntity, true);
toReturn = true;
}
}
return toReturn;
}
public bool Update(DiscountEntity _DiscountEntity, RelationPredicateBucket filter)
{
bool toReturn = false;
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
adapter.UpdateEntitiesDirectly(_DiscountEntity, filter);
toReturn = true;
}
return toReturn;
}
public bool Update(DiscountEntity _DiscountEntity)
{
bool toReturn = false;
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
RelationPredicateBucket filter = new RelationPredicateBucket();
IPredicateExpression _PredicateExpression = new PredicateExpression();
_PredicateExpression.Add(DiscountFields.Id == _DiscountEntity.Id);
filter.PredicateExpression.Add(_PredicateExpression);
adapter.UpdateEntitiesDirectly(_DiscountEntity, filter);
toReturn = true;
}
return toReturn;
}
public DiscountEntity SelectOne(Guid Id)
{
DiscountEntity toReturn = null;
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
DiscountEntity _DiscountEntity = new DiscountEntity(Id);
if (adapter.FetchEntity(_DiscountEntity))
{
toReturn = _DiscountEntity;
}
}
return toReturn;
}
public DiscountEntity Create([FromBody] DiscountEntity DiscountEntity)
{
return(DiscountService.Create(EmployeeEntity, DiscountEntity));
}
public DiscountEntity Update(Guid DiscountId, [FromBody] DiscountEntity DiscountEntity)
{
return(DiscountService.Update(EmployeeEntity, DiscountId, DiscountEntity));
}
public bool CanHandle(DiscountEntity discount)
{
return(discount.Type == DiscountEntityType.BuyTwoGetOneForFree);
}
public bool CanHandle(DiscountEntity discount)
{
return(discount.Type == DiscountEntityType.Percentage);
}
public Discount(DiscountEntity DiscountEntity) : base(DiscountEntity)
{
}
public static DiscountModel CTM(this DiscountEntity source) => new DiscountModel();
public DiscountEntity Insert(DiscountEntity _DiscountEntity)
{
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
adapter.SaveEntity(_DiscountEntity, true);
}
return _DiscountEntity;
}
public bool IsApplicable(BasketRecordEntity record, DiscountEntity entity)
{
return(record.Product.Id == entity.TargetProduct.Id);
}
public DiscountEntity Insert(string DiscountName, double PercentAmount, long IsActive)
{
DiscountEntity _DiscountEntity = new DiscountEntity();
using(DataAccessAdapterBase adapter = (new DataAccessAdapterFactory()).CreateAdapter())
{
_DiscountEntity.DiscountName = DiscountName;
_DiscountEntity.PercentAmount = PercentAmount;
_DiscountEntity.IsActive = IsActive;
adapter.SaveEntity(_DiscountEntity, true);
}
return _DiscountEntity;
}
