//--------------------------------------------------------
public string CreateReceiptString(Invoice invoice, ref List <ShoppingCartItem> gscList)
{
int itemNo = 1;
string receiptString = null;
PricingRule pr = null;
if (invoice != null)
{
receiptString = "\t\t\t" + invoice.CompanyName + "\t\t\n";
receiptString += "\t\t\t9999 Any Stree NW\t\t\n";
receiptString += "\t\t\tCalgary, AB T9T T9T\t\t\n";
receiptString += "\t\t\tCanada\t\t\n";
receiptString += "\t\t\tTel: 403-403-4040\t\t\n";
receiptString += "\t\t\tDate: " + DateTime.Now + "\t\t\n";
receiptString += "----------------------------------------------------------------------\n";
if (gscList != null && gscList.Count() > 0)
{
foreach (var item in gscList)
{
receiptString += itemNo + ".\t" + item.Product.Name + "\t" + item.Total + "\n";
pr = db.PricingRules.Find(item.PricingRuleId);
receiptString += "\t" + (itemNo++) + "\t" + pr.Name + "\t";
if (item.Discount > 0)
{
receiptString += item.Discount + "\n";
}
}
receiptString += "----------------------------------------------------------------------\n";
receiptString += "\tTotalDiscount: " + invoice.TotalDiscount + "\tTotal: " + invoice.Total + "\n";
}
}
return(receiptString);
}
private void insertPriceRule()
{
if (client != null)
{
int anz_rows = dataGridView3.RowCount;
int anz_col = dataGridView3.ColumnCount;
for (int i = 0; i <= anz_rows - 2; i++)
{
PricingRule pricerule = new PricingRule();
for (int y = 0; y <= anz_col - 1; y++)
{
if (dataGridView3.Columns[y].HeaderText == "Title")
{
pricerule.Title = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Item_code")
{
pricerule.ItemCode = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Selling")
{
pricerule.Selling = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Buying")
{
pricerule.Buying = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Min_qty")
{
pricerule.MinQTY = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Max_qty")
{
pricerule.MaxQTY = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Price_or_discount")
{
pricerule.PriceOrDiscount = dataGridView3[y, i].Value.ToString();
}
if (dataGridView3.Columns[y].HeaderText == "Price")
{
pricerule.Price = dataGridView3[y, i].Value.ToString();
}
}
ERPObject obj = pricerule.Object;
client.InsertObject(obj);
dataGridView3.Rows[i].DefaultCellStyle.BackColor = Color.Green;
}
MessageBox.Show("Import done", "Succesfull", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Please login first", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private bool IsValidOffer(Product product, PricingRule pricingRule)
{
if (pricingRule.Client == _client & pricingRule.Product == product & _itemCounters[product] == pricingRule.NumberOfItems)
{
_itemCounters[product] = 0;
return(true);
}
return(false);
}
//--------------------------------------------------------
public bool IsValidPricingRule(PricingRule pricingRule)
{
DateTime now = DateTime.Now;
if (pricingRule != null)
{
return(now > pricingRule.ExpDate ? true : false);
}
return(false);
}
private string ParseDiscountToString(PricingRule rule)
{
if (rule.Discount != null)
{
return(rule.Discount.ToString());
}
else
{
return("-");
}
}
//--------------------------------------------------------
public void CalculateCartItemTotal(ref List <PricingRule> prList, ref List <ShoppingCartItem> gscList)
{
//to keep track for item for BuyQuantityFor pricing rule
int BuyQuantityForIndex = 0, i = 0;
PricingRule buyQpr = null;
if (prList != null && gscList != null)
{
foreach (var item in gscList)
{
PricingRule pr = GetPricingRule(ref prList, item.Product.PricingRuleId);
item.Discount = ComputeBuyQuantityDiscount(pr, item);
if (pr.DiscountRuleEnumType == DiscountRuleEnum.BuyQuantityFor)
{
//to keep track for item for BuyQuantityFor pricing rule
BuyQuantityForIndex = i;
buyQpr = pr;
if (item.Quantity < pr.BuyQuantity)
{
item.Total = item.Product.Price * item.Quantity;
}
else
{
int tempMultiplier = (int)item.Quantity / (int)pr.BuyQuantity;
int discountMuliplier = (tempMultiplier == 0) ? 1 : tempMultiplier;
item.Total = pr.DiscountedPrice * discountMuliplier;
}
if (item.Quantity % pr.BuyQuantity > 0)
{
// ProcessBuyQuantityForRemainder(ref gscList, item, (int)(item.Quantity % pr.BuyQuantity));
//cannot update the gscList while foreach-loop is executing. So, must be done afterwards
item.Quantity = item.Quantity % pr.BuyQuantity;
item.BoughtQuantity = pr.BuyQuantity;
}
}
else
{
item.Total = item.Product.Price * item.Quantity - item.Discount;
}
i++;
}
//Now check for DiscountRuleEnum.BuyQuantityFor Remainder
if (gscList[BuyQuantityForIndex].Quantity > 0)
{
ProcessBuyQuantityForRemainder(ref gscList, gscList[BuyQuantityForIndex]);
}
}
}
//
// GET: /PricingRule/Create
public ActionResult Create()
{
PricingRule pr = new PricingRule();
IEnumerable <DiscountRuleEnum> enumTypeList = Enum.GetValues(typeof(DiscountRuleEnum)).Cast <DiscountRuleEnum>();
pr.DiscountRuleEnumTypeSelectList = from s in enumTypeList
select new SelectListItem
{
Text = s.ToString(),
Value = ((int)s).ToString()
};
return(View(pr));
}
public void SetPricingRule(PackageSizes size, CarrierCodes code)
{
switch (code)
{
case CarrierCodes.LP:
switch (size)
{
case PackageSizes.S:
Rule = new RegularPrice(size, code);
break;
case PackageSizes.M:
Rule = new RegularPrice(size, code);
break;
case PackageSizes.L:
if (DiscountData.LargaParcelCount == 3)
{
Rule = new PromotionPriceLargeParcel(size, code);
}
else
{
Rule = new RegularPrice(size, code);
}
DiscountData.LargaParcelCount++;
break;
}
break;
case CarrierCodes.MR:
switch (size)
{
case PackageSizes.S:
Rule = new PromotionPriceSmallParcel(size, code);
break;
case PackageSizes.M:
Rule = new RegularPrice(size, code);
break;
case PackageSizes.L:
Rule = new RegularPrice(size, code);
break;
}
break;
}
}
public ActionResult Create(PricingRule pr)
{
try
{
if (ModelState.IsValid)
{
pr.Name = pr.DiscountRuleEnumType.ToString();
db.PricingRules.Add(pr);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public decimal Total()
{
decimal totalAmount = 0.0m;
var productsGroupedByProductId = _products
.GroupBy(p => p.Id)
.Select(g => new { ProductId = g.Key, Products = g.ToList() })
.ToList();
foreach (var groupedProduct in productsGroupedByProductId)
{
List <Product> products = groupedProduct.Products;
PricingRule pricingRule = _pricingRules.Where(pr => pr.ProductID == groupedProduct.ProductId)
.FirstOrDefault();
if (pricingRule == null)
{
totalAmount += products.Sum(p => p.Price);
}
else
{
if (pricingRule.FixedQuantity.HasValue &&
products.Count >= pricingRule.FixedQuantity.Value)
{
int remainder = products.Count % pricingRule.FixedQuantity.Value;
int productCountToBeDiscounted = products.Count - remainder;
Product product = products.FirstOrDefault();
totalAmount += product.Price * (productCountToBeDiscounted / pricingRule.FixedQuantity.Value * pricingRule.DiscountedPriceByQuantity.Value);
totalAmount += product.Price * remainder;
}
else if (pricingRule.MinimumQuantity.HasValue &&
products.Count >= pricingRule.MinimumQuantity.Value)
{
totalAmount += products.Count * pricingRule.DiscountedPricePerProduct.Value;
}
}
}
return(totalAmount);
}
//--------------------------------------------------------
public decimal ComputeBuyQuantityDiscount(PricingRule pr, ShoppingCartItem scItem)
{
int discountCount = 0;
decimal discount = 0;
int discountMuliplier = 1;
if ((pr != null) && scItem != null && (scItem.Quantity > 0) &&
((pr.DiscountRuleEnumType == DiscountRuleEnum.BuyOneGetFree) ||
(pr.DiscountRuleEnumType == DiscountRuleEnum.BuyQuantityGetFree) ||
(pr.DiscountRuleEnumType == DiscountRuleEnum.BuyOneGetDiscount) ||
(pr.DiscountRuleEnumType == DiscountRuleEnum.BuyQuantityGetDiscount)
)
)
{
int tempMultiplier = (int)scItem.Quantity / (int)(pr.BuyQuantity + pr.DiscountQuantity);
discountMuliplier = (tempMultiplier == 0) ? 1 : tempMultiplier;
int tempCount = (int)(scItem.Quantity - pr.BuyQuantity);
if (pr.DiscountQuantity > 0)
{
discountCount = tempCount > (int)pr.DiscountQuantity ? (int)pr.DiscountQuantity : tempCount;
}
if (discountCount > 0)
{
discount = (decimal)(scItem.Product.Price * (pr.DiscountPercent) * discountCount * discountMuliplier) / 100;
}
}
else if ((pr != null) && (pr.DiscountRuleEnumType == DiscountRuleEnum.DiscountPercent))
{
discount = discount + (decimal)(scItem.Product.Price * pr.DiscountPercent / 100);
}
//else if ((pr != null) && (pr.DiscountRuleEnumType == DiscountRuleEnum.DiscountedAmount))
//discount = discount + (decimal)pr.DiscountedAmount;
return(discount);
}
//-----------------------------------------------
public List <PricingRule> CreatePricingRuleList(List <ShoppingCartItem> scList)
{
PricingRule pr = null;
List <PricingRule> prList = new List <PricingRule>();
if (scList != null && scList.Count() > 0)
{
foreach (var item in scList)
{
if (item.Product != null)
{
if (item.Product.PricingRuleId > 0)
{
pr = db.PricingRules.Find(item.Product.PricingRuleId);
if (pr != null && !ProcessPricingRules.IsFound(ref prList, pr.PricingRuleId))
{
prList.Add(pr);
}
}
}
}
}
return(prList);
}
public void AddPricingRule(PricingRule prule)
{
_pricingRulesRepo.Add(prule);
}
private string ParsePriceToString(PricingRule rule)
{
return(rule.Price.ToString());
}
public bool IsMatchingRule(PricingRule pricingRule, string item)
{
return(item.Count(x => x.ToString() == pricingRule.Name) >= pricingRule.SpecialPrice.Quantity);
}
public int QuantityOfSpecialPricesGroups(PricingRule rule, string item)
{
return(item.Count(x => x.ToString() == rule.Name) / rule.SpecialPrice.Quantity);
}
