public static async Task <List <UserReferral> > FetchReferrals(Guid payeeId) { CommerceEntities dbContext = BuildDBContext(); var query = from rp in dbContext.RewardPayouts join rr in dbContext.RewardReasons on rp.RewardReasonId equals rr.Id join rps in dbContext.RewardPayoutStatus on rp.RewardPayoutStatusId equals rps.Id where rp.PayeeId == payeeId && rp.RewardReasonId == 0 && (rp.RewardPayoutStatusId == UnprocessedRewardPayoutStatusId || rp.RewardPayoutStatusId == PaidRewardPayoutStatusId) orderby rp.PayoutScheduledDateUtc descending select new UserReferral { PayeeId = payeeId, AgentId = rp.AgentId, RewardReasonId = rp.RewardReasonId, RewardReason = rr.Name, Explanation = rp.Explanation, RewardPayoutStatusId = rp.RewardPayoutStatusId, RewardPayoutStatus = rps.Name, PayoutFinalizedDateUtc = rp.PayoutFinalizedDateUtc, PayoutScheduledDateUtc = rp.PayoutScheduledDateUtc, Amount = Math.Round((double)rp.Amount / 100, 2), }; return(await query.ToListAsync()); }
protected void Page_Load(object sender, EventArgs e) { using (CommerceEntities db = new CommerceEntities()) { try { var query = (from ProductOrders in db.OrderDetails join SelectedProducts in db.Products on ProductOrders.ProductID equals SelectedProducts.ProductID group ProductOrders by new { ProductId = SelectedProducts.ProductID, ModelName = SelectedProducts.ModelName } into grp select new { ModelName = grp.Key.ModelName, ProductId = grp.Key.ProductId, Quantity = grp.Sum(o => o.Quantity) } into orderdgrp where orderdgrp.Quantity > 0 orderby orderdgrp.Quantity descending select orderdgrp).Take(5); RepeaterItemsList.DataSource = query; RepeaterItemsList.DataBind(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Load Popular Items - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ protected void Page_Load(object sender, EventArgs e) { if (!String.IsNullOrEmpty(Request.QueryString["ProductID"])) { int productID = 0; Int32.TryParse(Request["productID"].ToString(), out productID); using (CommerceEntities db = new CommerceEntities()) { try { var thisProduct = (from p in db.Products where p.ProductID == productID select p).FirstOrDefault(); ModelName.Text = thisProduct.ModelName; } catch (Exception exp) { throw new Exception("ERROR: Unable to Add Product Review - " + exp.Message.ToString(), exp); } } } else { Debug.Fail("ERROR : We should never get to ReviewAdd.aspx without a ProductId."); throw new Exception("ERROR : It is illegal to load ReviewAdd.aspx without setting a ProductId."); } }
//------------------------------------------------------------------------------------------------------------------------------------------+ public void AddItem(string cartID, int productID, int quantity) { using (CommerceEntities db = new CommerceEntities()) { try { var myItem = (from c in db.ShoppingCarts where c.CartID == cartID && c.ProductID == productID select c).FirstOrDefault(); if (myItem == null) { ShoppingCart cartadd = new ShoppingCart(); cartadd.CartID = cartID; cartadd.Quantity = quantity; cartadd.ProductID = productID; cartadd.DateCreated = DateTime.Now; db.ShoppingCarts.AddObject(cartadd); } else { myItem.Quantity += quantity; } db.SaveChanges(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Add Item to Cart - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ public void UpdateShoppingCartDatabase(String cartId, ShoppingCartUpdates[] CartItemUpdates) { using (CommerceEntities db = new CommerceEntities()) { try { int CartItemCOunt = CartItemUpdates.Count(); var myCart = (from c in db.ViewCarts where c.CartID == cartId select c); foreach (var cartItem in myCart) { // Iterate through all rows within shopping cart list for (int i = 0; i < CartItemCOunt; i++) { if (cartItem.ProductID == CartItemUpdates[i].ProductId) { if (CartItemUpdates[i].PurchaseQuantity < 1 || CartItemUpdates[i].RemoveItem == true) { RemoveItem(cartId, cartItem.ProductID); } else { UpdateItem(cartId, cartItem.ProductID, CartItemUpdates[i].PurchaseQuantity); } } } } } catch (Exception exp) { throw new Exception("ERROR: Unable to Update Cart Database - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ protected void Page_PreRender(object sender, EventArgs e) { if (_ProductId < 1) { // This should never happen but we could expand the use of this control by reducing the // dependency on the query string by selecting a few RANDOME products here. Debug.Fail("ERROR : The Also Purchased Control Can not be used without setting the ProductId."); throw new Exception("ERROR : It is illegal to load the AlsoPurchased COntrol without setting a ProductId."); } int ProductCount = 0; using (CommerceEntities db = new CommerceEntities()) { try { var v = db.SelectPurchasedWithProducts(_ProductId); ProductCount = v.Count(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Retrieve Also Purchased Items - " + exp.Message.ToString(), exp); } } if (ProductCount > 0) { WriteAlsoPurchased(_ProductId); } else { WritePopularItems(); } }
private static CommerceEntities BuildDBContext() { CommerceEntities dbContext = new CommerceEntities(); dbContext.Database.CommandTimeout = 0; return(dbContext); }
public static async Task <List <Settlement> > FetchSettlementsByFilter(TransactionsFilter filter) { CommerceEntities dbContext = BuildDBContext(); var query = from rr in dbContext.RedemptionReports join offers in dbContext.Offers on rr.DealId equals offers.GlobalID join rd in dbContext.RedeemedDeals on rr.TransactionId equals rd.Id join m in dbContext.Merchants on rd.MerchantNameId equals m.Id join cardBrands in dbContext.CardBrands on rr.CardBrand equals cardBrands.Name select new Settlement { PartnerName = rr.PartnerName, CardBrandId = cardBrands.Id, CardBrandName = rr.CardBrand, LastFourDigits = rr.LastFourDigits, PartnerMerchantId = m.Id, MerchantName = m.Name, AuthorizationDateTimeLocal = rr.AuthorizationDateTimeLocal, AuthorizationDateTimeUtc = rr.AuthorizationDateTimeUtc, UtcReachedTerminalState = rr.UtcReachedTerminalState, TransactionTypeId = offers.OfferType, TransactionType = offers.OfferType == EarnTransactionType ? "Earn" : "Burn", AuthorizationAmount = Math.Round((double)rr.AuthorizationAmount / 100, 2), SettlementAmount = Math.Round((double)rr.SettlementAmount / 100, 2), DiscountAmount = Math.Round((double)rr.DiscountAmount / 100, 2), CreditStatus = rr.CreditStatus, CurrentState = rr.CurrentState, GlobalUserId = rr.GlobalUserID }; if (filter.StartDate.HasValue && filter.EndDate.HasValue) { query = query.Where(x => filter.StartDate <= x.UtcReachedTerminalState && x.UtcReachedTerminalState < filter.EndDate); } if (filter.TransactionTypes != null && filter.TransactionTypes.Any()) { query = query.Where(x => filter.TransactionTypes.Contains(x.TransactionTypeId)); } if (filter.CardBrandIds != null && filter.CardBrandIds.Any()) { query = query.Where(x => filter.CardBrandIds.Contains(x.CardBrandId)); } if (!string.IsNullOrWhiteSpace(filter.Last4Digits)) { query = query.Where(x => x.LastFourDigits == filter.Last4Digits); } if (!string.IsNullOrWhiteSpace(filter.MerchantName) && filter.MerchantName != AllMerchants) { query = query.Where(x => x.MerchantName == filter.MerchantName); } query = query.OrderByDescending(x => x.UtcReachedTerminalState); return(await query.ToListAsync()); }
public static async Task <int> FetchUserIdByGlobalId(Guid globalUserId) { CommerceEntities dbContext = BuildDBContext(); var query = from u in dbContext.Users where u.GlobalId == globalUserId select u.Id; return(await query.FirstAsync()); }
public static async Task <List <DataContract.Commerce.CardBrand> > FetchCardBrandsAsync() { CommerceEntities dbContext = BuildDBContext(); var query = from cb in dbContext.CardBrands select new DataContract.Commerce.CardBrand { Id = cb.Id, Name = cb.Name }; return(await query.ToListAsync()); }
public static async Task <List <EarnBurnHistoryRecord> > GetEarnBurnHistory(Guid userId) { CommerceEntities commerceDbContext = new CommerceEntities(); // Tenders Dictionary <int, string> tenders = await(from trs in commerceDbContext.ReimbursementTenders select trs).ToDictionaryAsync(x => x.Id, x => x.Name); // Cards Dictionary <int, string> cardBrands = await(from cb in commerceDbContext.CardBrands select cb).ToDictionaryAsync(x => x.Id, x => x.Name); // Credit Status Dictionary <int, string> creditStatus = await(from trs in commerceDbContext.CreditStatus select trs).ToDictionaryAsync(x => x.Id, x => x.Name); CustomerServiceEntities customerServiceDbContext = new CustomerServiceEntities(); var query = (from h in customerServiceDbContext.GetEarnBurnHistory(userId) orderby h.PurchaseDateTime descending select new EarnBurnHistoryRecord { ReimbursementTenderId = h.ReimbursementTenderId, MerchantName = h.MerchantName, DiscountSummary = h.DiscountSummary, Percent = h.Percent, PurchaseDateTime = h.PurchaseDateTime, AuthorizationAmount = Math.Round((double)h.AuthorizationAmount / 100, 2), Reversed = h.Reversed, CreditStatusId = h.CreditStatusId, DiscountAmount = Math.Round((double)h.DiscountAmount / 100, 2), LastFourDigits = h.LastFourDigits, CardBrandId = h.CardBrandId, }).ToList(); foreach (var record in query) { record.ReimbursementTender = record.ReimbursementTenderId.HasValue && tenders.ContainsKey(record.ReimbursementTenderId.Value) ? tenders[record.ReimbursementTenderId.Value] : string.Empty; record.CreditStatus = record.CreditStatusId.HasValue && creditStatus.ContainsKey(record.CreditStatusId.Value) ? creditStatus[record.CreditStatusId.Value] : string.Empty; record.CardBrand = record.CardBrandId.HasValue && cardBrands.ContainsKey(record.CardBrandId.Value) ? cardBrands[record.CardBrandId.Value] : string.Empty; } return(query); }
public static async Task <List <DataContract.Commerce.Merchant> > FetchMerchantsAsync() { CommerceEntities dbContext = BuildDBContext(); var query = from m in dbContext.Merchants orderby m.Name select new DataContract.Commerce.Merchant { Id = m.Id, Name = m.Name }; return(await query.ToListAsync()); }
//------------------------------------------------------------------------------------------------------------------------------------------+ public bool SubmitOrder(string UserName) { using (CommerceEntities db = new CommerceEntities()) { try { //------------------------------------------------------------------------+ // Add New Order Record | //------------------------------------------------------------------------+ Order newOrder = new Order(); newOrder.CustomerName = UserName; newOrder.OrderDate = DateTime.Now; newOrder.ShipDate = CalculateShipDate(); db.Orders.AddObject(newOrder); db.SaveChanges(); //------------------------------------------------------------------------+ // Create a new OderDetail Record for each item in the Shopping Cart | //------------------------------------------------------------------------+ String cartId = GetShoppingCartId(); var myCart = (from c in db.ViewCarts where c.CartID == cartId select c); foreach (ViewCart item in myCart) { int i = 0; if (i < 1) { OrderDetail od = new OrderDetail(); od.OrderID = newOrder.OrderID; od.ProductID = item.ProductID; od.Quantity = item.Quantity; od.UnitCost = item.UnitCost; db.OrderDetails.AddObject(od); i++; } var myItem = (from c in db.ShoppingCarts where c.CartID == item.CartID && c.ProductID == item.ProductID select c).FirstOrDefault(); if (myItem != null) { db.DeleteObject(myItem); } } db.SaveChanges(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Submit Order - " + exp.Message.ToString(), exp); } } return(true); }
//------------------------------------------------------------------------------------------------------------------------------------------+ private void WriteAlsoPurchased(int currentProduct) { using (CommerceEntities db = new CommerceEntities()) { try { var v = db.SelectPurchasedWithProducts(currentProduct); RepeaterItemsList.DataSource = v; RepeaterItemsList.DataBind(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Write Also Purchased - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ public void UpdateItem(string cartID, int productID, int quantity) { using (CommerceEntities db = new CommerceEntities()) { try { var myItem = (from c in db.ShoppingCarts where c.CartID == cartID && c.ProductID == productID select c).FirstOrDefault(); if (myItem != null) { myItem.Quantity = quantity; db.SaveChanges(); } } catch (Exception exp) { throw new Exception("ERROR: Unable to Update Cart Item - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ public decimal GetTotal(string cartID) { using (CommerceEntities db = new CommerceEntities()) { decimal cartTotal = 0; try { var myCart = (from c in db.ViewCarts where c.CartID == cartID select c); if (myCart.Count() > 0) { cartTotal = myCart.Sum(od => (decimal)od.Quantity * (decimal)od.UnitCost); } } catch (Exception exp) { throw new Exception("ERROR: Unable to Calculate Order Total - " + exp.Message.ToString(), exp); } return(cartTotal); } }
//------------------------------------------------------------------------------------------------------------------------------------------+ public void MigrateCart(String oldCartId, String UserName) { using (CommerceEntities db = new CommerceEntities()) { try { var myShoppingCart = from cart in db.ShoppingCarts where cart.CartID == oldCartId select cart; foreach (ShoppingCart item in myShoppingCart) { item.CartID = UserName; } db.SaveChanges(); Session[CartId] = UserName; } catch (Exception exp) { throw new Exception("ERROR: Unable to Migrate Shopping Cart - " + exp.Message.ToString(), exp); } } }
//------------------------------------------------------------------------------------------------------------------------------------------+ protected void ReviewAddBtn_Click(object sender, ImageClickEventArgs e) { if (Page.IsValid == true) { // Obtain ProductID from Page State int productID = Int32.Parse(Request["productID"]); // Obtain Rating number of RadioButtonList int rating = Int32.Parse(Rating.SelectedItem.Value); // Add Review to ReviewsDB. HtmlEncode before entry using (CommerceEntities db = new CommerceEntities()) { try { ShoppingCart cartadd = new ShoppingCart(); Review newReview = new Review() { ProductID = productID, Rating = rating, CustomerName = HttpUtility.HtmlEncode(Name.Text), CustomerEmail = HttpUtility.HtmlEncode(Email.Text), Comments = HttpUtility.HtmlEncode(UserComment.Content) }; db.Reviews.AddObject(newReview); db.SaveChanges(); } catch (Exception exp) { throw new Exception("ERROR: Unable to Update Cart Item - " + exp.Message.ToString(), exp); } } Response.Redirect("ProductDetails.aspx?ProductID=" + productID); } Response.Redirect("ProductList.aspx"); }
public static async Task <List <CardInfo> > FetchCardInfo(Guid globalUserId) { CommerceEntities dbContext = BuildDBContext(); var query = from c in dbContext.Cards join cb in dbContext.CardBrands on c.CardBrand equals cb.Id join u in dbContext.Users on c.UserId equals u.Id where u.GlobalId == globalUserId orderby c.Active descending select new CardInfo { Id = c.Id, UserId = c.UserId, GlobalUserId = u.GlobalId, Last4Digits = c.LastFourDigits, CardBrandId = c.CardBrand, CardBrand = cb.Name, DateAddedUTC = c.UtcAdded, Active = c.Active, Token = c.PartnerToken }; return(await query.ToListAsync()); }
public static async Task <List <Transaction> > FetchTransactionsByFilter(TransactionsFilter filter) { CommerceEntities dbContext = BuildDBContext(); var query = from auth in dbContext.Authorizations join tr in dbContext.TransactionLinks on auth.ClaimedDealId equals tr.Id join merchants in dbContext.Merchants on auth.MerchantNameId equals merchants.Id join cards in dbContext.Cards on tr.CardId equals cards.Id join cardBrands in dbContext.CardBrands on cards.CardBrand equals cardBrands.Id join offers in dbContext.Offers on tr.DealId equals offers.Id join users in dbContext.Users on tr.UserId equals users.Id orderby tr.DateAdded descending select new Transaction { TransactionLinkId = tr.Id, DateAdded = auth.DateAdded, MerchantId = merchants.Id, MerchantName = merchants.Name, TransactionTypeId = offers.OfferType, TransactionType = offers.OfferType == EarnTransactionType ? "Earn" : "Burn", Percent = offers.PercentBack, TransactionAmount = Math.Round((double)auth.TransactionAmount / 100, 2), DiscountAmount = Math.Round((double)auth.DiscountAmount / 100, 2), LastFourDigits = cards.LastFourDigits, CardBrandId = cards.CardBrand, CardBrandName = cardBrands.Name, UserGlobalId = users.GlobalId }; if (filter.StartDate.HasValue && filter.EndDate.HasValue) { query = query.Where(x => filter.StartDate <= x.DateAdded && x.DateAdded < filter.EndDate); } if (filter.TransactionTypes != null && filter.TransactionTypes.Any()) { query = query.Where(x => filter.TransactionTypes.Contains(x.TransactionTypeId)); } if (filter.CardBrandIds != null && filter.CardBrandIds.Any()) { query = query.Where(x => filter.CardBrandIds.Contains(x.CardBrandId)); } if (!string.IsNullOrWhiteSpace(filter.Last4Digits)) { query = query.Where(x => x.LastFourDigits == filter.Last4Digits); } if (!string.IsNullOrWhiteSpace(filter.MerchantName) && filter.MerchantName != AllMerchants) { query = query.Where(x => x.MerchantName == filter.MerchantName); } if (filter.UserId.HasValue) { query = query.Where(x => x.UserGlobalId == filter.UserId); } query = query.OrderBy(x => x.DateAdded); return(await query.ToListAsync()); }
public static async Task <List <EarnBurnLineItem> > GetEarnBurnLineItems(Guid userId) { CommerceEntities commerceDbContext = new CommerceEntities(); // Cards Dictionary <int, string> cardBrands = await(from cb in commerceDbContext.CardBrands select cb).ToDictionaryAsync(x => x.Id, x => x.Name); // TransactionReviewStatus Dictionary <int, string> trReviewStatus = await(from trs in commerceDbContext.TransactionReviewStatus select trs).ToDictionaryAsync(x => x.Id, x => x.Name); // Credit Status Dictionary <int, string> creditStatus = await(from trs in commerceDbContext.CreditStatus select trs).ToDictionaryAsync(x => x.Id, x => x.Name); CustomerServiceEntities customerServiceDbContext = new CustomerServiceEntities(); customerServiceDbContext.Database.CommandTimeout = 0; var query = from li in customerServiceDbContext.QueryEarnBurnLineItems() where li.GlobalId == userId orderby li.TransactionDate descending select new EarnBurnLineItem { TransactionId = li.TransactionId, UserId = li.GlobalId, TransactionDate = li.TransactionDate, EarnCredit = Math.Round((double)li.EarnCredit / 100, 2), BurnDebit = Math.Round((double)li.BurnDebit / 100, 2), HasRedeemedDealRecord = li.HasRedeemedDealRecord, TransactionTypeId = li.TransactionType, DealSummary = li.DealSummary, DealPercent = li.DealPercent, MerchantName = li.MerchantName, TransactionAmount = Math.Round((double)li.TransactionAmount / 100, 2), Reversed = li.Reversed, TransactionStatusId = li.TransactionStatusId, Last4Digits = li.LastFourDigits, CardBrandId = li.CardBrand, PermaPending = li.PermaPending, ReviewStatusId = li.ReviewStatusId, RedeemDealId = li.RedeemedDealId }; List <EarnBurnLineItem> result = await query.ToListAsync(); foreach (var row in result) { row.TransactionType = row.TransactionTypeId == CommerceDal.BurnTransactionType ? "Burn" : "Earn"; row.TransactionStatus = row.TransactionStatusId.HasValue && creditStatus.ContainsKey(row.TransactionStatusId.Value) ? creditStatus[row.TransactionStatusId.Value] : string.Empty; row.CardBrand = row.CardBrandId.HasValue && cardBrands.ContainsKey(row.CardBrandId.Value) ? cardBrands[row.CardBrandId.Value] : string.Empty; row.ReviewStatus = row.ReviewStatusId.HasValue && trReviewStatus.ContainsKey(row.ReviewStatusId.Value) ? trReviewStatus[row.ReviewStatusId.Value] : string.Empty; } return(result); }