private bool SaveCouponInstance(CouponDTO dto, out string error)
{
try
{
var entities = CouponInstanceRepository.GetMany(x => x.CouponId == dto.CouponId).ToList();
if (!entities.Any())
{
CouponInstanceRepository.Add(dto.CourseCouponDto2CouponInstanceEntity());
}
else
{
if (entities.Count().Equals(1))
{
var entity = entities[0];
entity.UpdateCouponInstanceEntity(dto);
}
//else
//{
//TODO ask for logic
//}
}
return(CouponInstanceRepository.UnitOfWork.CommitAndRefreshChanges(out error));
}
catch (Exception ex)
{
error = Utils.FormatError(ex);
return(false);
}
}
public static void UpdateCouponInstanceEntity(this CouponInstances entity, CouponDTO dto)
{
entity.CouponCode = dto.CouponName.OptimizedUrl();
entity.UsageLimit = dto.UsageLimit ?? -1;
entity.UpdateDate = DateTime.Now;
entity.UpdatedBy = DtoExtensions.CurrentUserId;
}
public async Task ApplyCouponDiscountTest()
{
CouponDTO couponDTO = _mapper.Map <CouponDTO>(MockModels.MockCouponModel());
double discountAmount = await cart.ApplyCouponDiscountAsync(_cartDTO, couponDTO);
Assert.Positive(discountAmount);
}
private async Task <double> CheckCouponDiscountAmountAsync(CartDTO cart, CouponDTO coupon)
{
double discountAmount = 0;
double totalCartCost = 0;
IList <CartDetailDTO> cartDetailDTOs = await GetCartDetailsAsync(cart.CartId);
foreach (CartDetailDTO item in cartDetailDTOs)
{
ProductDTO productDTO = _mapper.Map <ProductDTO>(await _productEFService.GetProductAsync(item.ProductId));
totalCartCost += productDTO.Price * item.ProductQuantity;
}
if (totalCartCost >= coupon.MinimumCartCost)
{
switch (coupon.DiscountType)
{
case DiscountType.Rate:
discountAmount = (totalCartCost - await GetCampaignDiscountAsync(cart)) * coupon.Discount / 100;
break;
case DiscountType.Amount:
discountAmount = coupon.Discount;
break;
default:
break;
}
}
return(discountAmount);
}
public static void ExpireCoupon()
{
List <CouponDTO> CouponDTOList = new List <CouponDTO>();
CouponDTOList = CouponService.GetCouponListWhichNotExpired();
if (CouponDTOList != null)
{
foreach (var item in CouponDTOList)
{
EcouponCampaignDTO EcouponCampaignDTO = new EcouponCampaignDTO();
EcouponCampaignDTO = EcouponCampaignService.GetById(item.EcouponCampaignId);
if (EcouponCampaignDTO.ExpiresOn != null)
{
if (EcouponCampaignDTO.ExpiresOn < System.DateTime.Now)
{
CouponDTO CouponDTO = new CouponDTO();
CouponDTO = item;// CouponService.GetById(item.Id);
CouponDTO.IsExpired = true;
CouponService.Edit(CouponDTO);
}
}
}
}
}
public ActionResult ApplyCoupon(String couponCode)
{
//var checkout = Session["checkout"] as CheckOutDTO;
if (_couponService.CheckCoupon(couponCode))
{
CouponDTO couppDto = _couponService.GetCoupon(couponCode, CurrentLanguage, CurrentCurrency);
var Message = "";
if (couppDto.IsPercentage)
{
Message = couppDto.Value.ToString();
Message += " %" + "حسم";
}
else
{
Message = "- " + couppDto.ValueDisplay;
}
// checkout.Coupon = couppDto;
//Session["checkout"] = checkout;
_checkOutService.SetCoupon(User.Identity.GetUserId(), couponCode);
return(Json(new OperationDetails(true, Message, Utils.GetValueCurrencyDisplay(Utils.getCurrencyName(CurrentCurrency, CurrentLanguage), checkout.TotalCost))));
}
else
{
//checkout.Coupon = new CouponDTO();
return(Json(new OperationDetails(false, "كوبون غير صالح", "")));
}
}
public Coupon ToCoupon(CouponDTO coupon)
{
if (coupon == null)
{
throw new ArgumentNullException("coupon");
}
return(new Coupon(coupon.ID, coupon.Name, coupon.CanUse, coupon.Value, coupon.ExpiryDate));
}
public async Task <ActionResult <CouponDTO> > CreateCoupon([FromBody] CouponDTO couponDto)
{
var insertedId = await _discountRepository.CreateCoupon(_mapper.Map <Coupon>(couponDto));
var newCoupon = await _discountRepository.GetCoupon(insertedId);
return(CreatedAtRoute(nameof(GetCoupon), new { id = newCoupon.Id }, _mapper.Map <CouponDTO>(newCoupon)));
}
public static void UpdateCouponEntity(this Coupons entity, CouponDTO dto)
{
entity.CouponName = dto.CouponName;
entity.CouponTypeId = (byte)dto.Type;
entity.CouponTypeAmount = (double?)(dto.Amount ?? 0);
entity.ExpirationDate = dto.ExpirationDate;
entity.SubscriptionMonths = dto.SubscriptionMonths;
entity.UpdateDate = DateTime.Now;
entity.UpdatedBy = DtoExtensions.CurrentUserId;
}
public static CouponDTO CouponToDTO(Coupon Coupon)
{
if (Coupon == null)
{
return(null);
}
Mapper.CreateMap <Coupon, CouponDTO>();
CouponDTO CouponDTO = Mapper.Map <CouponDTO>(Coupon);
return(CouponDTO);
}
private async Task SaveCouponAsync(CartDTO cart, CouponDTO coupon, double discountAmount)
{
CartCouponDTO cartCouponDTO = new CartCouponDTO
{
CartId = cart.CartId,
CouponId = coupon.CouponId,
DiscountAmount = discountAmount
};
CartCouponModel cartCouponModel = _mapper.Map <CartCouponModel>(cartCouponDTO);
await _cartEFService.SaveCartCouponAsync(cartCouponModel, cart.CartId);
}
public static CouponInstances CourseCouponDto2CouponInstanceEntity(this CouponDTO dto, string code)
{
return(new CouponInstances
{
CouponId = dto.CouponId
, CouponCode = code
, UsageLimit = dto.UsageLimit ?? -1
, AddOn = DateTime.Now
, CreatedBy = DtoExtensions.CurrentUserId
});
}
public static Coupon CouponToDomain(CouponDTO CouponDTO)
{
if (CouponDTO == null)
{
return(null);
}
Mapper.CreateMap <CouponDTO, Coupon>();
Coupon Coupon = Mapper.Map <Coupon>(CouponDTO);
return(Coupon);
}
public async Task <double> ApplyCouponDiscountAsync(CartDTO cart, CouponDTO coupon)
{
double discountAmount = 0;
double tempDiscountAmount = await CheckCouponDiscountAmountAsync(cart, coupon); //Apply the ruleset of coupon and return discount amount
if (tempDiscountAmount > discountAmount) //if discount exist then save and apply the coupon
{
discountAmount = tempDiscountAmount;
await SaveCouponAsync(cart, coupon, discountAmount);
}
return(discountAmount);
}
public async Task <ActionResult> CreateCoupon([FromBody] CouponDTO coupon)
{
var couponRepo = _mapper.Map <Coupon>(coupon);
_repo.Add(couponRepo);
if (await _repo.SaveAll())
{
return(Ok(coupon));
}
return(BadRequest("Adding category error"));
}
public CouponDTO GetCoupon(string couponCode, Langs l, Currency currency)
{
Coupon coupon = unitOfWork.CouponRepository.Get(c => c.Code == couponCode).FirstOrDefault();
if (coupon == null)
{
return(new CouponDTO());
}
CouponDTO couponDTO = new CouponDTO();
couponDTO.Code = coupon.Code;
couponDTO.CurrencyName = Utils.getCurrencyName(currency, l);
couponDTO.Id = coupon.Id;
couponDTO.IsPercentage = coupon.IsPercentage;
couponDTO.Value = coupon.Value;
if (!coupon.IsPercentage)
{
couponDTO.Value = Utils.getCurrency(currency, l, coupon.Value).Item1;
}
return(couponDTO);
}
public CouponDTO RedeemCoupon(CouponDTO CouponDTO)
{
try
{
//return CouponService.RedeemCoupon(Id, Remark, ClientUserId);
return(CouponService.RedeemCoupon(CouponDTO));
}
catch (TimeoutException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.RequestTimeout)
{
Content = new StringContent("An error occurred, please try again or contact the administrator."),
ReasonPhrase = "Critical Exception"
});
}
catch (Exception)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("An error occurred, please try again or contact the administrator."),
ReasonPhrase = "Critical Exception"
});
}
}
public async Task <int> CreateNewCouponAsync(CouponDTO coupon)
{
return(await _couponEFService.AddCouponAsync(_mapper.Map <CouponModel>(coupon)));
}
public async Task OnGet()
{
CategoryDTO categoryDTO = new CategoryDTO()
{
Tittle = "Food2"
};
Category category = new Category(_mapper, _categoryEFService);
categoryDTO.CategoryId = await category.CreateNewCategoryAsync(categoryDTO);
ProductDTO productAppleDTO = new ProductDTO()
{
CategoryId = categoryDTO.CategoryId,
Price = 100,
Tittle = "Apple"
};
ProductDTO productAlmondDTO = new ProductDTO()
{
CategoryId = categoryDTO.CategoryId,
Price = 150,
Tittle = "Almond"
};
Product product = new Product(_mapper, _productEFService);
productAppleDTO.ProductId = await product.CreateProductAsync(productAppleDTO);
productAlmondDTO.ProductId = await product.CreateProductAsync(productAlmondDTO);
Cart cart = new Cart(_cartEFService, _mapper, _productEFService, _categoryEFService);
CartDetailDTO cartDetailDTO1 = new CartDetailDTO()
{
ProductId = productAlmondDTO.ProductId,
ProductQuantity = 3
};
CartDetailDTO cartDetailDTO2 = new CartDetailDTO()
{
ProductId = productAppleDTO.ProductId,
ProductQuantity = 1
};
CartDTO cartDTO = new CartDTO()
{
CustomerId = 1
};
cartDTO.CartId = await cart.CreateCartAsync(cartDTO);
await cart.AddItemAsync(cartDTO.CartId, productAppleDTO, 3);
List <CampaignDTO> campaigns = new List <CampaignDTO>();
CampaignDTO campaignDTO1 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 20,
DiscountType = DiscountType.Rate,
Quantity = 3
};
CampaignDTO campaignDTO2 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 50,
DiscountType = DiscountType.Rate,
Quantity = 5
};
CampaignDTO campaignDTO3 = new CampaignDTO()
{
CategoryId = categoryDTO.CategoryId,
Discount = 5,
DiscountType = DiscountType.Amount,
Quantity = 5
};
Campaign campaign = new Campaign(_mapper, _campaignEFService);
campaignDTO1.CampaignId = await campaign.CreateCampaignAsync(campaignDTO1);
campaignDTO2.CampaignId = await campaign.CreateCampaignAsync(campaignDTO2);
campaignDTO3.CampaignId = await campaign.CreateCampaignAsync(campaignDTO3);
campaigns.Add(campaignDTO1);
campaigns.Add(campaignDTO2);
campaigns.Add(campaignDTO3);
await cart.ApplyCampaignDiscountAsync(cartDTO, campaigns);
CouponDTO couponDTO = new CouponDTO()
{
Discount = 10,
DiscountType = ECommerce.Business.Models.DiscountType.Rate,
MinimumCartCost = 100
};
Coupon coupon = new Coupon(_mapper, _couponEFService);
couponDTO.CouponId = await coupon.CreateNewCouponAsync(couponDTO);
await cart.ApplyCouponDiscountAsync(cartDTO, couponDTO);
Delivery delivery = new Delivery(_deliveryEFService, _cartEFService, _productEFService, _categoryEFService, _mapper);
double costPerDelivery = _configuration.GetValue <double>("CostPerDelivery");
double costPerProduct = _configuration.GetValue <double>("CostPerProduct");
double fixedCost = _configuration.GetValue <double>("FixedCost");
double deliveryCost = await delivery.CalculateDeliveryCostAndCountAsync(cartDTO.CartId, costPerDelivery, costPerProduct, fixedCost);
double cartAmount = await cart.GetTotalAmountAfterDiscountsAsync(cartDTO);
double couponDiscount = await cart.GetCouponDiscountAsync(cartDTO);
double campaignDiscount = await cart.GetCampaignDiscountAsync(cartDTO);
double getDeliveryCost = await delivery.GetDeliveryCostAsync(cartDTO);
IList <PrintModel> printModels = await cart.PrintAsync(cartDTO);
}
public async Task <ActionResult <bool> > UpdateCoupon([FromBody] CouponDTO couponDto)
{
return(await _discountRepository.UpdateCoupon(_mapper.Map <Coupon>(couponDto)));
}
private static bool ActualSmsSend(string mobilenumber, string message, string Gateway, EcouponCampaignDTO EcouponCampaignDTO, ClientDTO ClientDTO, string CouponCode)
{
string result = "";
bool IsSent = false;
int SMSMsgCount = GetMessageCount(message);
message = MsgCorrect(message);
if (message != "" && mobilenumber != "")// Check for empty message.
{
string Url = ConfigurationManager.AppSettings["TransactionalGateWay"].ToString();
Url = Url.Replace("%26", "&");
Url = Url.Replace("[recipient]", mobilenumber);
Url = Url.Replace("[message]", message);
if (Gateway != "022751") //if (Gateway.ToLower() != "default")
{
Url = Url.Replace("[gateway]", Gateway); //Gateway = "MSGBLS"
}
else
{
Url = "";
Url = ConfigurationManager.AppSettings["PromotionalGateWay"].ToString();
Url = Url.Replace("%26", "&");
Url = Url.Replace("[recipient]", mobilenumber);
Url = Url.Replace("[message]", message);
}
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(Url);
myRequest.Method = "GET";
WebResponse myResponse = myRequest.GetResponse();
StreamReader sr = new StreamReader(myResponse.GetResponseStream(), System.Text.Encoding.UTF8);
result = sr.ReadToEnd();
sr.Close();
string statuscode = "";
if (result.Contains('|'))
{
statuscode = result.Substring(0, result.IndexOf('|'));
}
else
{
statuscode = result;
}
string SMSReplyMessage = SMSResult(statuscode) + "-" + result; //result
myResponse.Close();
if (statuscode == "1701")
{
IsSent = true;
CouponDTO CouponDTO = new CouponDTO();
//CouponDTO.IsSuccess = true;
CouponDTO.EcouponCampaignId = EcouponCampaignDTO.Id;
CouponDTO.MobileNumber = mobilenumber;
CouponDTO.Code = CouponCode;
CouponDTO.IsRedeem = false;
CouponDTO.MessageId = result;
SettingDTO SettingDTO = new SettingDTO();
SettingDTO = SettingService.GetById(1);
double ActualSMSMsgCount = SettingDTO.NationalCouponSMSCount * SMSMsgCount;
CouponDTO.MessageCount = SMSMsgCount;
CouponDTO.RequiredCredits = ActualSMSMsgCount;
CouponDTO.Message = message;
//CouponDTO.MessageStatus = SMSReplyMessage;
//CouponDTO.GatewayID = Gateway;
CouponDTO.SentDateTime = System.DateTime.Now;
CouponDTO.IsCouponSent = true;
//CouponDTO.MessageID = statuscode;
//if (statuscode == "1701")
//{
// CampaignLogDTO.IsSuccess = true;
//}
//else if (statuscode != "1701")
//{
// CampaignLogDTO.IsSuccess = false;
//}
CouponService.Create(CouponDTO);
//// Reduce SMS Credits From Client
//ClientDTO.SMSCredit = ClientDTO.SMSCredit - ActualSMSMsgCount; // SMSMsgCount;
//ClientService.Edit(ClientDTO);
}
}
return(IsSent);// result;
}
