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);
}
