protected void Page_Init(object sender, EventArgs e)
{
_OrderId = AbleCommerce.Code.PageHelper.GetOrderId();
_Order = OrderDataSource.Load(_OrderId);
if (_Order == null)
{
Response.Redirect("Default.aspx");
}
string suffix = "?OrderNumber=" + _Order.OrderNumber;
AddProductLink.NavigateUrl += suffix;
AddOtherItemLink.NavigateUrl += suffix;
RecalculateTaxesButton.Visible = TaxHelper.IsATaxProviderEnabled();
BindGrids();
TaxExemptionMessagePanel.Visible = !string.IsNullOrEmpty(this._Order.TaxExemptionReference);
if (TaxExemptionMessagePanel.Visible)
{
TaxExemptionMessage.Text = string.Format(TaxExemptionMessage.Text, this._Order.TaxExemptionReference);
}
// WE DON'T SUPPORT TAX CLOUD TAX RECALCULATION
TaxGateway taxGateway = null;
TaxCloudProvider taxProvider = null;
int taxGatewayId = TaxGatewayDataSource.GetTaxGatewayIdByClassId(Misc.GetClassId(typeof(TaxCloudProvider)));
if (taxGatewayId > 0)
{
taxGateway = TaxGatewayDataSource.Load(taxGatewayId);
}
if (taxGateway != null)
{
taxProvider = taxGateway.GetProviderInstance() as TaxCloudProvider;
}
if (taxProvider != null && taxProvider.EnableTaxCloud)
{
TaxCloudWarningMessagePanel.Visible = true;
TaxCloudReclaculationMessage.Text = string.Format(TaxCloudReclaculationMessage.Text, _Order.OrderNumber);
}
}
protected void AuditEventGrid_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
AuditEvent auditEvent = (AuditEvent)e.Row.DataItem;
if (auditEvent.EventType == AuditEventType.ViewCardData)
{
Order order = OrderDataSource.Load(AlwaysConvert.ToInt(auditEvent.RelatedId));
if (order != null)
{
PlaceHolder phRe = (PlaceHolder)e.Row.FindControl("phRe");
if (phRe != null)
{
HyperLink link = new HyperLink();
link.NavigateUrl = _OrderUrl + "?OrderNumber=" + order.OrderNumber.ToString();
link.Text = "Order #" + order.OrderNumber.ToString();
phRe.Controls.Add(link);
}
}
}
}
}
/// <summary>
/// Loads orders based on the current filter.
/// </summary>
/// <param name="maximumRows">Maximum number of rows to return</param>
/// <param name="startRowIndex">Starting index of first record in result set</param>
/// <param name="sortExpression">Sort expression to apply to the result set</param>
/// <returns>A collection of orders matching the filter</returns>
public OrderCollection Load(int maximumRows, int startRowIndex, string sortExpression)
{
Database database = Token.Instance.Database;
// GET THE IDS OF THE ORDERS IN THE REQUESTED SET
int thisIndex = 0;
int rowCount = 0;
List <string> orderIds = new List <string>();
DbCommand selectCommand = GetFilteredOrderIds(maximumRows, startRowIndex, sortExpression, false);
using (IDataReader dr = database.ExecuteReader(selectCommand))
{
while (dr.Read() && ((maximumRows < 1) || (rowCount < maximumRows)))
{
if (thisIndex >= startRowIndex)
{
orderIds.Add(dr.GetInt32(0).ToString());
rowCount++;
}
thisIndex++;
}
dr.Close();
}
// LOAD THE ORDERS IN THE REQUESTED SET
OrderCollection orders = new OrderCollection();
if (orderIds.Count > 1)
{
string criteria = "OrderId IN (" + string.Join(",", orderIds.ToArray()) + ")";
orders = OrderDataSource.LoadForCriteria(criteria, sortExpression);
}
else if (orderIds.Count == 1)
{
orders.Add(OrderDataSource.Load(Convert.ToInt32(orderIds[0])));
}
return(orders);
}
private void DoExpressCheckout()
{
PayPalProvider client = AbleCommerce.Code.StoreDataHelper.GetPayPalProvider();
PayPalProvider.ExpressCheckoutResult result = client.DoExpressCheckout();
// LOOK FOR AN ORDERID TO INDICATE THE CHECKOUT SUCCEEDED
if (result.OrderId != 0)
{
// ORDER ID LOCATED, SEND TO THE RECEIPT PAGE
Order order = OrderDataSource.Load(result.OrderId);
Response.Redirect(AbleCommerce.Code.NavigationHelper.GetReceiptUrl(order.OrderNumber));
}
// THE CHECKOUT FAILED, SEE IF WE HAVE ERRORS AVAIALBLE
if (result.Errors != null && result.Errors.Count > 0)
{
RedirectWithErrors(result.Errors);
}
// NO ERRORS AVAILABLE, USE DEFAULT
RedirectWithDefaultError();
}
protected void Print_Click(object sender, EventArgs e)
{
string scriptKey = "scriptKey";
if (!Page.ClientScript.IsStartupScriptRegistered(Page.GetType(), scriptKey))
{
this.Page.ClientScript.RegisterStartupScript(this.GetType(), scriptKey, "window.print();", true);
}
IList <int> selectedOrders = GetSelectedOrders();
if ((selectedOrders == null) || (selectedOrders.Count == 0))
{
return;
}
foreach (int orderId in selectedOrders)
{
Order order = OrderDataSource.Load(orderId);
if (order != null)
{
EventsManager.Instance.RaiseInventoryPullSheetPrinted(null, new OrderEventArgs(order));
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
string tempDateFilter = Request.QueryString["DateFilter"];
if (string.IsNullOrEmpty(tempDateFilter))
{
tempDateFilter = "THISMONTH";
}
UpdateDateFilter(tempDateFilter);
DateTime startDate = AlwaysConvert.ToDateTime(Request.QueryString["StartDate"], DateTime.MinValue);
DateTime endDate = AlwaysConvert.ToDateTime(Request.QueryString["EndDate"], DateTime.MaxValue);
if (startDate != DateTime.MinValue)
{
StartDate.SelectedDate = startDate;
}
if (endDate != DateTime.MaxValue)
{
EndDate.SelectedDate = endDate;
}
//BIND THE COUPON LIST
CouponList.DataSource = OrderDataSource.GetCouponCodes();
CouponList.DataBind();
//INITIALIZE COUPON LIST
string couponCode = Request.QueryString["CouponCode"];
ListItem listItem = CouponList.Items.FindByValue(couponCode);
if (listItem != null)
{
CouponList.SelectedIndex = CouponList.Items.IndexOf(listItem);
}
//GENERATE REPORT ON FIRST VISIT
ReportButton_Click(sender, e);
}
}
private List <int> GetSelectedOrderIds()
{
List <int> selectedOrders = new List <int>();
if (AlwaysConvert.ToBool(SelectAll.Value, false))
{
OrderFilter filter = GetOrderFilter();
IList <Order> orders = OrderDataSource.LoadForFilter(filter, 0, 0, "OrderNumber ASC");
foreach (Order order in orders)
{
selectedOrders.Add(order.Id);
}
}
else
{
int[] orderNumbers = AlwaysConvert.ToIntArray(Request.Form["OID"]);
IDictionary <int, int> orderIds = OrderDataSource.LookupOrderIds(orderNumbers);
foreach (int orderId in orderIds.Values)
{
selectedOrders.Add(orderId);
}
}
return(selectedOrders);
}
/// <summary>
/// Gets a collection of unshipped shipments for the selected orders.
/// </summary>
/// <param name="orders">The orderIds to gather shipments for.</param>
/// <returns>A collection of unshipped shipments for the selected orders.</returns>
protected IList <OrderShipment> GetShipments(params int[] orders)
{
bool includeShipped = AlwaysConvert.ToInt(Request.QueryString["is"]) == 1;
int shipmentNumber = AlwaysConvert.ToInt(Request.QueryString["ShipmentNumber"]);
IList <OrderShipment> shipments = new List <OrderShipment>();
foreach (int orderId in orders)
{
Order order = OrderDataSource.Load(orderId);
if (order != null)
{
foreach (OrderShipment shipment in order.Shipments)
{
if ((shipmentNumber == 0 || shipmentNumber == shipment.ShipmentNumber) &&
(includeShipped || !shipment.IsShipped))
{
shipments.Add(shipment);
}
}
}
}
ShipmentCount = shipments.Count;
return(shipments);
}
public void Process()
{
string googleOrderNum = N1.googleordernumber;
Order order = OrderDataSource.LoadForGoogleOrderNumber(googleOrderNum);
if (order == null)
{
Logger.Warn("Unknown Google Order Number Order State Changed. GoogleOrderNumber=" + googleOrderNum);
}
else
{
//update financial order payment status
Payment payment = AcHelper.GetGCPayment(order, GatewayInstance, true);
switch (N1.newfinancialorderstate)
{
case FinancialOrderState.CHARGEABLE:
//authorized
payment.PaymentStatusReason = N1.reason;
if (payment.PaymentStatus == PaymentStatus.AuthorizationPending)
{
PaymentEngine.ProcessAuthorizePending(payment, GatewayInstance.PaymentGatewayId, true);
}
break;
case FinancialOrderState.CHARGING:
//capture pending
break;
case FinancialOrderState.CANCELLED:
case FinancialOrderState.CANCELLED_BY_GOOGLE:
//cancel the order
//if the order has been paid order cancellation will be preceeded by a refund notification
//so that aspect will be handled in refund handler
//TODO: Do we need to force void the remaining payments?
//payment.PaymentStatusReason = N1.reason;
//PaymentEngine.ForceVoid(payment, GatewayInstance.PaymentGatewayId, true);
if (order.OrderStatus.IsValid)
{
if (!string.IsNullOrEmpty(N1.reason))
{
OrderNote on = new OrderNote();
on.Comment = "Order Cancelled : " + N1.reason;
on.OrderId = order.OrderId;
order.Notes.Add(on);
}
order.Cancel();
}
break;
case FinancialOrderState.CHARGED:
//charge the payment
//we will handle this in charge amount notification handler only
//otherwise it can result in double charge transactions
/*payment.PaymentStatusReason = N1.reason;
* if (payment.PaymentStatus == PaymentStatus.CapturePending)
* {
* PaymentEngine.ProcessCapturePending(payment, GatewayInstance.PaymentGatewayId, true);
* }*/
break;
case FinancialOrderState.PAYMENT_DECLINED:
//payment declined
payment.PaymentStatusReason = N1.reason;
if (payment.PaymentStatus == PaymentStatus.CapturePending)
{
PaymentEngine.ProcessCapturePending(payment, GatewayInstance.PaymentGatewayId, false);
}
else if (payment.PaymentStatus == PaymentStatus.AuthorizationPending)
{
PaymentEngine.ProcessAuthorizePending(payment, GatewayInstance.PaymentGatewayId, false);
}
else
{
PaymentEngine.ForceCapture(payment, GatewayInstance.PaymentGatewayId, false);
}
break;
case FinancialOrderState.REVIEWING:
//No AC equivalent
default:
break;
}
//TODO : order statuses are custom defined in AC
//update order shipment status
switch (N1.newfulfillmentorderstate)
{
case FulfillmentOrderState.NEW:
//do nothing
break;
case FulfillmentOrderState.DELIVERED:
//order has been shipped
foreach (OrderShipment os in order.Shipments)
{
if (!os.IsShipped)
{
os.Ship(false);
}
}
break;
case FulfillmentOrderState.PROCESSING:
//no equivalent in AC
break;
case FulfillmentOrderState.WILL_NOT_DELIVER:
//this may happen if order is cancelled
//order cancelled event will take care of this
break;
default:
break;
}
}
}
public void Process()
{
TraceContext trace = WebTrace.GetTraceContext();
string traceKey = "GoogleCheckout.AC.NewOrderHandler";
trace.Write(traceKey, "Begin NewOrderHandler.Process, Google order number " + N1.googleordernumber);
Order order = OrderDataSource.LoadForGoogleOrderNumber(N1.googleordernumber);
if (order == null) // ordernumber not already entered
{
trace.Write(traceKey, "Google order not present in database, get basket");
Basket basket = AcHelper.GetAcBasket(N1.shoppingcart, true);
if (basket == null)
{
trace.Write(traceKey, "Basket could not be obtained (End NewOrderHandler.Process)");
return;
}
//basket is ready. check if there are any order adjustments to be made
trace.Write(traceKey, "Check for order adjustments");
OrderAdjustment orderAdj = N1.orderadjustment;
if (orderAdj != null)
{
trace.Write(traceKey, "Order adjustments present, add to basket");
OrderAdjustmentHelper.DoOrderAdjustments(orderAdj, basket);
}
trace.Write(traceKey, "set billing address");
Users.Address primaryAddress = basket.User.PrimaryAddress;
AcHelper.PopulateAcAddress(primaryAddress, N1.buyerbillingaddress);
trace.Write(traceKey, "set shipping address");
Users.Address shipAddr = AcHelper.GetAcAddress(basket.User, N1.buyershippingaddress);
basket.User.Addresses.Add(shipAddr);
basket.User.Save();
trace.Write(traceKey, "package the basket");
basket.Package(false);
if (basket.Shipments.Count > 0)
{
//there are shippable items / shipments
//set shipment address and shipment method
trace.Write(traceKey, "shippable items present, get shipping method");
ShipMethod shipMethod = AcHelper.GetShipMethod(basket);
trace.Write(traceKey, "ship method is " + shipMethod.Name + " (ID" + shipMethod.ShipMethodId.ToString() + ")");
foreach (BasketShipment shipment in basket.Shipments)
{
shipment.AddressId = shipAddr.AddressId;
shipment.ShipMethodId = shipMethod.ShipMethodId;
shipment.Save();
}
//have to link the shipping charges with some shipment.
//we can't know which shipment. Just link to the first.
trace.Write(traceKey, "assign shipping charges to first shipment");
BasketShipment basketShipment = basket.Shipments[0];
foreach (BasketItem item in basket.Items)
{
if (item.OrderItemType == OrderItemType.Shipping)
{
item.BasketShipmentId = basketShipment.BasketShipmentId;
//update the sku and shipping method name so that scrubbed name is not used
item.Name = shipMethod.Name;
item.Sku = string.Empty;
}
}
}
trace.Write(traceKey, "save basket");
basket.Save();
//now checkout the order with null payment.
//this will alow payment to be processed later
trace.Write(traceKey, "submit basket checkout");
CheckoutRequest acCheckout = new CheckoutRequest(null);
CheckoutResponse acResp = basket.Checkout(acCheckout);
if (acResp.Success)
{
trace.Write(traceKey, "checkout was successful, update the google order number for AC order number " + acResp.OrderNumber.ToString());
order = OrderDataSource.Load(acResp.OrderId, false);
if (order != null)
{
//update email address associated with order
order.BillToEmail = N1.buyerbillingaddress.email;
order.GoogleOrderNumber = N1.googleordernumber;
bool isPaidByGc = false;
//IF THERE IS ONE PAYMENT AND IT IS A GIFT CERTIFICATE
//AND IT COVERS THE BALANCE OF THE ORDER THEN THIS IS THE GOOGLE PAYMENT
if (order.Payments.Count == 1)
{
int gcPayMethodId = PaymentEngine.GetGiftCertificatePaymentMethod().PaymentMethodId;
Payment payment = order.Payments[0];
if (payment.PaymentMethodId == gcPayMethodId)
{
if (payment.Amount == order.TotalCharges)
{
isPaidByGc = true;
}
}
}
if (!isPaidByGc)
{
//We need to create a new payment with status of authorization pending
Payment payment = new Payment();
payment.PaymentMethodId = AcHelper.GetGCPaymentMethodId(this.GatewayInstance);
payment.Amount = order.GetBalance(false);
payment.OrderId = order.OrderId;
payment.PaymentMethodName = "GoogleCheckout";
Transaction trans = new Transaction();
trans.TransactionType = TransactionType.Authorize;
trans.TransactionStatus = TransactionStatus.Pending;
trans.Amount = payment.Amount;
trans.PaymentGatewayId = this.GatewayInstance.PaymentGatewayId;
trans.ProviderTransactionId = N1.googleordernumber;
trans.TransactionDate = N1.timestamp;
payment.Transactions.Add(trans);
payment.PaymentStatus = PaymentStatus.AuthorizationPending;
order.Payments.Add(payment);
}
order.Save();
}
else
{
OrderDataSource.UpdateGoogleOrderNumber(acResp.OrderId, N1.googleordernumber);
}
}
else
{
trace.Write(traceKey, "checkout failed for google order");
CommerceBuilder.Utility.Logger.Warn("GoogleCheckout : New Order Checkout Failed.");
}
trace.Write(traceKey, "Send AC order number back to Google");
AcNotifier.AddMerchantOrderNumber(GatewayInstance, N1.googleordernumber, acResp.OrderNumber.ToString());
}
else
{
//order number already entered. Just send notification
trace.Write(traceKey, "Google order in database, send AC order number back to Google");
AcNotifier.AddMerchantOrderNumber(GatewayInstance, N1.googleordernumber, order.OrderNumber.ToString());
}
trace.Write(traceKey, "End NewOrderHandler.Process");
}
protected bool HasOrders(object dataItem)
{
OrderStatus os = (OrderStatus)dataItem;
return(OrderDataSource.CountForOrderStatus(os.Id) > 0);
}
/// <summary>
/// Migrates data such as profile settings and basket contents from one user to another.
/// </summary>
/// <param name="oldUser">The user that provides the source data.</param>
/// <param name="newUser">The user to receive the data.</param>
/// <param name="includeOrderData">If true, order history and address book are migrated.</param>
/// <param name="isNewUserAccount">If true, newUser represents an account just created.</param>
public static void Migrate(User oldUser, User newUser, bool includeOrderData, bool isNewUserAccount)
{
//FAIL MIGRATION IF REQUIRED PARAMETERS MISSING
if (oldUser == null)
{
throw new ArgumentNullException("oldUser");
}
if (newUser == null)
{
throw new ArgumentNullException("newUser");
}
//ONLY MIGRATE IF USERID DOES NOT MATCH
if (oldUser.UserId != newUser.UserId)
{
//MIGRATE AFFILIATE SETTINGS
if (oldUser.Affiliate != null && oldUser.AffiliateId != newUser.AffiliateId)
{
// A VALID AFFILIATE WAS SET ON THE OLD USER AND IS NOT THE ONE ASSOCIATED WITH NEW USER
// SHOULD WE UPDATE THE USER?
StoreSettingCollection settings = Store.GetCachedSettings();
if (isNewUserAccount ||
settings.AffiliateReferralRule == ReferralRule.NewSignupsOrExistingUsersOverrideAffiliate ||
(settings.AffiliateReferralRule == ReferralRule.NewSignupsOrExistingUsersNoOverride && newUser.AffiliateId == 0))
{
// EITHER A NEW SIGNUP
// OR THE RULE IS TO ALWAYS OVERRIDE
// OR AN EXISTING USER WITH NO AFFILIATE SET WITH EXISTING USERS NO OVERRIDE OPTION
// AFFILIATE SHOULD BE UPDATED FOR THE TARGET USER
newUser.AffiliateId = oldUser.AffiliateId;
newUser.AffiliateReferralDate = oldUser.AffiliateReferralDate;
}
// UPDATE USERS WITH NEW AFFILIATE ASSOCIATIONS
newUser.Save();
oldUser.AffiliateId = 0;
oldUser.AffiliateReferralDate = DateTime.MinValue;
oldUser.Save();
}
//TRANSFER BASKET IF NEEDED
Basket.Transfer(oldUser.UserId, newUser.UserId);
Wishlist.Transfer(oldUser.UserId, newUser.UserId);
// TRANSFER PAGE VIEW HISTORY
PageViewDataSource.UpdateUser(oldUser.UserId, newUser.UserId);
//SHOULD WE TRANSFER ORDER DATA?
if (includeOrderData)
{
//REASSIGN ORDERS AND ADDRESSES TO NEW USER
OrderDataSource.UpdateUser(oldUser.UserId, newUser.UserId);
AddressDataSource.UpdateUser(oldUser.UserId, newUser.UserId);
}
else if (oldUser.IsAnonymous)
{
//BUG 7740, ERASE ANY ADDRESS INFO ASSOCIATED WITH ANON ACCOUNT
oldUser.Addresses.DeleteAll();
oldUser.PrimaryAddressId = 0;
oldUser.Save();
}
}
}
protected void CancelButton_Click(object sender, EventArgs e)
{
int orderNumber = OrderDataSource.LookupOrderNumber(_Payment.OrderId);
Response.Redirect("Default.aspx?OrderNumber=" + orderNumber.ToString());
}
public void ProcessRequest(HttpContext context)
{
HttpResponse Response = context.Response;
//GET THE ORDER ID FROM THE URL
int orderId = AlwaysConvert.ToInt(context.Request.QueryString["o"]);
Order order = OrderDataSource.Load(orderId);
if (order != null)
{
//MAKE SURE ORDER IS FOR CURRENT USER
User user = AbleContext.Current.User;
if (order.User != null && order.User.Id == user.Id)
{
//CLEAR THE EXISTING BASKET
List <string> basketMessages = new List <string>();
Basket basket = user.Basket;
IBasketService basketService = AbleContext.Resolve <IBasketService>();
basketService.Clear(basket);
foreach (OrderItem item in order.Items)
{
if ((item.OrderItemType == OrderItemType.Product) && (!item.IsChildItem))
{
Product product = item.Product;
if ((product != null) && (product.Visibility != CommerceBuilder.Catalog.CatalogVisibility.Private))
{
BasketItem basketItem;
try
{
basketItem = BasketItemDataSource.CreateForProduct(item.Product.Id, item.Quantity, item.OptionList, item.KitList);
basketItem.IsSubscription = item.IsSubscription;
if (!item.IsSubscription && item.Product != null)
{
basketItem.IsSubscription = item.Product.IsSubscription;
}
basketItem.Frequency = item.Frequency;
basketItem.FrequencyUnit = item.FrequencyUnit;
}
catch
{
string itemName = item.Name;
if (!string.IsNullOrEmpty(item.VariantName))
{
itemName += " (" + item.VariantName + ")";
}
basketMessages.Add("The item " + itemName + " is no longer available.");
basketItem = null;
}
if (basketItem != null)
{
//SEE IF A PRODUCT TEMPLATE IS ASSOCIATED
foreach (ProductTemplate template in product.ProductTemplates)
{
if (template != null)
{
foreach (InputField inputField in template.InputFields)
{
if (!inputField.IsMerchantField)
{
//COPY OVER ANY CUSTOMER INPUTS
BasketItemInput itemInput = new BasketItemInput();
itemInput.BasketItem = basketItem;
itemInput.InputField = inputField;
itemInput.InputValue = GetItemInputValue(item, inputField.Name);
basketItem.Inputs.Add(itemInput);
}
}
}
}
if ((basketItem.OrderItemType == OrderItemType.Product) && (basketItem.Product.UseVariablePrice))
{
basketItem.Price = item.Price;
}
basketItem.Basket = basket;
basket.Items.Add(basketItem);
//WE HAVE TO SAVE THE BASKET IN CASE IT IS NOT YET CREATED
basket.Save();
}
}
}
}
if (context.Session != null)
{
context.Session["BasketMessage"] = basketMessages;
}
Response.Redirect(NavigationHelper.GetBasketUrl());
}
}
Response.Redirect(NavigationHelper.GetHomeUrl());
}
protected IList <Order> GetAffiliateOrders(object dataItem)
{
AffiliateSalesSummary summary = (AffiliateSalesSummary)dataItem;
return(OrderDataSource.LoadForAffiliate(summary.AffiliateId, summary.StartDate, summary.EndDate, "OrderId ASC"));
}
public void ProcessRequest(HttpContext context)
{
//GET REFERENCE TO REQUEST
HttpRequest request = context.Request;
HttpResponse response = context.Response;
TraceContext trace = context.Trace;
//RECORD FORM VALUES TO TRACE OUTPUT
foreach (string key in request.Form)
{
context.Trace.Write(key + ":" + request.Form[key]);
}
//SETUP DEFAULT REDIRECT URL
string redirectUrl = "~/Default.aspx";
//INITIALIZE THE PAYPAL PROVIDER
PaymentGateway paypalGateway = PayPalProvider.GetPayPalPaymentGateway(true);
if (paypalGateway == null)
{
response.Redirect(redirectUrl);
}
//LOOK FOR ORDER ID
int orderId;
string customValue = request.Form["custom"];
if (!String.IsNullOrEmpty(customValue))
{
int index = customValue.IndexOf(":");
if (index > 0)
{
orderId = AlwaysConvert.ToInt(customValue.Substring(0, index));
}
else
{
orderId = AlwaysConvert.ToInt(customValue);
}
}
else
{
// TRY TO LOCATE ORDER ID AS QUERY STRING PARAMETER
orderId = AlwaysConvert.ToInt(request.QueryString["OrderId"]);
}
//IF ORDER ID WAS NOT IN CUSTOM, SEE IF WE CAN FIND THE ORDER VIA TRANSACTION ID
if (orderId == 0)
{
trace.Write("OrderId not found in custom field; lookup via transaction ID");
string parentTransactionId = IpnProcessor.GetFormValue(request.Form, "parent_txn_id");
if (!string.IsNullOrEmpty(parentTransactionId) && (paypalGateway != null))
{
trace.Write("Query for parent transaction " + parentTransactionId);
orderId = FindPayPalOrderId(paypalGateway.PaymentGatewayId, parentTransactionId);
if (orderId != 0)
{
trace.Write("Order ID Found: " + orderId.ToString());
}
}
}
//TRY TO LOAD ORDER
Order order = OrderDataSource.Load(orderId);
//IF ORDER LOAD FAILS, STOP PROCESSING AND REDIRECT
if (order == null)
{
response.Redirect(redirectUrl);
}
//ORDER LOAD SUCCESSFUL, UPDATE DEFAULT REDIRECT URL
redirectUrl = "~/Members/MyOrder.aspx?OrderId=" + orderId.ToString();
//IF GATEWAY NOT FOUND, STOP PROCESSING AND REDIRECT
PayPalProvider provider = (PayPalProvider)paypalGateway.GetInstance();
//GET TRANSACTION AMOUNT
LSDecimal curSignedPayment = AlwaysConvert.ToDecimal(request.Form["mc_gross"]);
LSDecimal curPayment = Math.Abs((Decimal)curSignedPayment);
context.Trace.Write("Transaction Amount is " + curPayment.ToString());
if (curPayment != 0)
{
//VERIFY PAYMENT NOTIFICATION WITH PAYPAL
bool valid = provider.ValidateNotification(request.Form.ToString());
if (!valid)
{
response.Redirect(redirectUrl);
}
//VERIFY THE RECEIVER EMAIL
string lowerReceiverEmail = AlwaysConvert.ToString(request.Form["receiver_email"]).ToLowerInvariant();
string lowerProviderAccount = provider.PayPalAccount.ToLowerInvariant();
if (lowerReceiverEmail != lowerProviderAccount)
{
context.Trace.Write("Receiver Email (" + lowerReceiverEmail + ") does not match Primary Account (" + lowerProviderAccount + ")");
response.Redirect(redirectUrl);
}
//CHECK WHETHER TRANSACTION IS ALREADY PRESENT IN DATABASE
string paypalTransactionId = IpnProcessor.GetFormValue(request.Form, "txn_id");
string authTransactionId = IpnProcessor.GetFormValue(request.Form, "auth_id");
string paymentStatus = IpnProcessor.GetFormValue(request.Form, "payment_status").ToUpperInvariant();
string authStatus = IpnProcessor.GetFormValue(request.Form, "auth_status").ToUpperInvariant();
context.Trace.Write("Transaction ID Is " + paypalTransactionId);
context.Trace.Write("Payment Status Is " + paymentStatus);
context.Trace.Write("Auth Status Is " + authStatus);
//CHECK FOR THIS PAYPAL TRANSACTION (MATCHING PROVIDER, PAYPAL TRANSACTION ID, AND PAYMENT STATUS)
Payment payment = null;
Transaction pendingTransaction = null;
if (!string.IsNullOrEmpty(paypalTransactionId))
{
TransactionCollection matchingTransactions = TransactionDataSource.LoadForProviderTransaction(paypalGateway.PaymentGatewayId, paypalTransactionId);
foreach (Transaction tx in matchingTransactions)
{
//WHEN PAYMENT IS BY ECHECK, IPN ISSUES A PENDING TRANSACTION
//SECOND IPN COMES FOR COMPLETED STATUS USING SAME TRANSACTION ID
if ((tx.ResponseCode == "PENDING") && (paymentStatus != "PENDING"))
{
//WE HAVE TO GET THE TRANSACTION VIA THE PAYMENT OBJECT
//OTHERWISE WE WILL HAVE PROBLEMS WITH DATA CONSISTENCY LATER
payment = tx.Payment;
foreach (Transaction ptx in payment.Transactions)
{
if (ptx.TransactionId == tx.TransactionId)
{
pendingTransaction = ptx;
}
}
}
else if ((tx.TransactionType != TransactionType.Void) && (paymentStatus == "VOIDED"))
{
//IF WE VOID AN AUTHORIZATION, THE VOID HAS THE SAME TXID
//THE AUTHORIZATION WILL HAVE A BLANK RESPONSE CODE
//THE VOID SHOULD HAVE A 'VOIDED' RESPONSE CODE
//(THIS TRANSACTION IS NOT A MATCH AND SHOULD BE IGNORED)
}
else
{
//NO FURTHER PROCESSING, REDIR TO ORDER SCREEN
context.Trace.Write("Transaction ID " + paypalTransactionId + " Already Exists in Database");
response.Redirect(redirectUrl);
}
}
}
Transaction transaction = null;
PaymentMethod paypalMethod = PayPalProvider.GetPayPalPaymentMethod(true);
PaymentCollection orderPayments = order.Payments;
Transaction authTransaction = null;
PaymentStatus[] validAuthStatuses = { PaymentStatus.Unprocessed, PaymentStatus.AuthorizationPending };
context.Trace.Write("Processing Payment Status: " + paymentStatus);
switch (paymentStatus)
{
case "PENDING":
//THIS IS A PENDING TRANSACTION, GET PENDING REASON AND FIND OUT IF IT IS AN ECHECK WAITING TO CLEAR
string pendingReason = IpnProcessor.GetFormValue(request.Form, "pending_reason").ToLowerInvariant();
bool isPendingeCheck = (pendingReason == "echeck");
bool isPendingAuthorization = (pendingReason == "authorization");
context.Trace.Write("Pending Reason: " + pendingReason);
context.Trace.Write("Is Pending eCheck: " + isPendingeCheck.ToString());
context.Trace.Write("Is Pending Authorization: " + isPendingAuthorization.ToString());
//FIND THE PAYPAL PAYMENT THAT IS UNPROCESSED OR PENDING AUTHORIZATION
payment = FindPaypalPayment(paypalMethod.PaymentMethodId, orderPayments, validAuthStatuses);
if (payment != null)
{
//SEE IF WE CAN FIND A PENDING PAYPAL TRANSACTION WITHOUT A TXID
foreach (Transaction tx in payment.Transactions)
{
if ((tx.ResponseCode == "PENDING") && string.IsNullOrEmpty(tx.ProviderTransactionId))
{
transaction = tx;
}
}
}
//IF WE DID NOT FIND AN EXISTING TRANSACTION, CREATE A NEW ONE
if (transaction == null)
{
transaction = new Transaction();
}
//UPDATE THE TRANSACTION VALUES
transaction.TransactionType = (isPendingeCheck ? TransactionType.Capture : TransactionType.Authorize);
transaction.PaymentGatewayId = paypalGateway.PaymentGatewayId;
transaction.ProviderTransactionId = IpnProcessor.GetFormValue(request.Form, "txn_id");
transaction.TransactionDate = AlwaysConvert.ToDateTime(request.Form["payment_date"], DateTime.UtcNow).ToUniversalTime();
transaction.Amount = AlwaysConvert.ToDecimal(IpnProcessor.GetFormValue(request.Form, "mc_gross"));
transaction.TransactionStatus = TransactionStatus.Successful;
if (isPendingAuthorization)
{
//THIS IS AN EXPECTED RESPONSE, NO NEED TO SAVE THE REASON CODES
transaction.ResponseMessage = string.Empty;
transaction.ResponseCode = string.Empty;
}
else
{
transaction.ResponseMessage = pendingReason;
transaction.ResponseCode = "PENDING";
}
transaction.AuthorizationCode = IpnProcessor.GetFormValue(request.Form, "auth_id");
transaction.RemoteIP = IpnProcessor.GetFormValue(request.ServerVariables, "REMOTE_ADDR");
transaction.Referrer = IpnProcessor.GetFormValue(request.ServerVariables, "HTTP_REFERER");
//CREATE A PAYMENT IF AN EXISTING ONE WAS NOT FOUND
if (payment == null)
{
payment = new Payment();
payment.OrderId = orderId;
payment.PaymentMethodId = paypalMethod.PaymentMethodId;
payment.PaymentMethodName = paypalMethod.Name;
order.Payments.Add(payment);
}
//UPDATE PAYMENT DETAILS
payment.ReferenceNumber = IpnProcessor.GetFormValue(request.Form, "payer_email");
payment.Amount = transaction.Amount;
payment.PaymentDate = transaction.TransactionDate;
if (isPendingAuthorization)
{
payment.PaymentStatus = PaymentStatus.Authorized;
payment.PaymentStatusReason = string.Empty;
}
else
{
payment.PaymentStatus = (isPendingeCheck ? PaymentStatus.CapturePending : PaymentStatus.AuthorizationPending);
payment.PaymentStatusReason = transaction.ResponseMessage;
}
//ADD IN TRANSACTION
payment.Transactions.Add(transaction);
break;
case "COMPLETED":
//IF THIS IS A CAPTURE FROM AN AUTHORIZATION, FIND THE AUTHORIZATION TRANSACTION
//AND UPDATE THE STATUS ACCORDINGLY, DEPENDING ON WHETHER ADDITIONAL SETTLEMENT TRANSACTIONS REMAIN (INTREMSETTLE > 0)
authTransaction = null;
authTransactionId = IpnProcessor.GetFormValue(request.Form, "auth_id");
if (!string.IsNullOrEmpty(authTransactionId))
{
TransactionCollection matchingTransactions = TransactionDataSource.LoadForProviderTransaction(paypalGateway.PaymentGatewayId, authTransactionId);
//SHOULD ONLY BE ONE
if (matchingTransactions.Count > 0)
{
authTransaction = matchingTransactions[0];
}
}
//IF PAYPAL IS RUNNING IN CAPTURE MODE, WE MAY HAVE A COMPLETED PAYMENT
//WITH A PENDING OR UNPROCESSED PAYMENT ALREADY ASSOCIATED TO ORDER
if (pendingTransaction == null)
{
//FIND THE PAYPAL PAYMENT THAT IS UNPROCESSED OR PENDING
payment = FindPaypalPayment(paypalMethod.PaymentMethodId, orderPayments, validAuthStatuses);
if (payment != null)
{
//SEE IF WE CAN FIND A PENDING PAYPAL TRANSACTION WITHOUT A TXID
foreach (Transaction tx in payment.Transactions)
{
if ((tx.ResponseCode == "PENDING") && string.IsNullOrEmpty(tx.ProviderTransactionId))
{
pendingTransaction = tx;
}
}
}
}
//SEE IF THIS TRANSACTION WAS PENDING (SUCH AS A CHECK WAITING TO CLEAR)
if (pendingTransaction != null)
{
//GET THE PENDING TRANSACTION AND PAYMENT
payment = order.Payments[order.Payments.IndexOf(pendingTransaction.PaymentId)];
transaction = payment.Transactions[payment.Transactions.IndexOf(pendingTransaction.TransactionId)];
}
else
{
//THIS IS NOT A PENDING TRANSACTION
//LOCATE THE APPROPRIATE PAYMENT
if (authTransaction != null)
{
payment = order.Payments[order.Payments.IndexOf(authTransaction.PaymentId)];
}
else
{
//FIND THE PAYPAL PAYMENT THAT CAN BE CAPTURED
PaymentStatus[] validCaptureStatuses = { PaymentStatus.Unprocessed, PaymentStatus.AuthorizationPending, PaymentStatus.Authorized, PaymentStatus.CaptureFailed, PaymentStatus.CapturePending };
payment = FindPaypalPayment(paypalMethod.PaymentMethodId, orderPayments, validCaptureStatuses);
//CREATE A PAYMENT IF AN EXISTING ONE WAS NOT FOUND
if (payment == null)
{
payment = new Payment();
payment.OrderId = orderId;
payment.PaymentMethodId = paypalMethod.PaymentMethodId;
payment.PaymentMethodName = paypalMethod.Name;
order.Payments.Add(payment);
}
}
//CREATE A NEW TRANSACTION RECORD
transaction = new Transaction();
transaction.PaymentId = payment.PaymentId;
}
//UPDATE THE TRANSACTION DETAILS
transaction.TransactionType = TransactionType.Capture;
transaction.PaymentGatewayId = paypalGateway.PaymentGatewayId;
transaction.TransactionDate = AlwaysConvert.ToDateTime(request.Form["payment_date"], DateTime.UtcNow).ToUniversalTime();
transaction.RemoteIP = IpnProcessor.GetFormValue(request.ServerVariables, "REMOTE_ADDR");
transaction.Referrer = IpnProcessor.GetFormValue(request.ServerVariables, "HTTP_REFERER");
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.ProviderTransactionId = IpnProcessor.GetFormValue(request.Form, "txn_id");
transaction.AuthorizationCode = IpnProcessor.GetFormValue(request.Form, "auth_id");
transaction.Amount = AlwaysConvert.ToDecimal(IpnProcessor.GetFormValue(request.Form, "mc_gross"));
transaction.ResponseCode = paymentStatus;
transaction.ResponseMessage = string.Empty;
//HANDLE PARTIAL / FINAL CAPTURES
int remainingSettle = AlwaysConvert.ToInt(IpnProcessor.GetFormValue(request.Form, "remaining_settle"));
if (remainingSettle == 0)
{
//THIS IS A FINAL CAPTURE
transaction.TransactionType = TransactionType.Capture;
//SET PAYMENT AMOUNT TO SUM OF ALL CAPTURES
LSDecimal totalCaptures = 0;
foreach (Transaction tx in payment.Transactions)
{
if ((transaction.TransactionId != tx.TransactionId) &&
(tx.TransactionType == TransactionType.PartialCapture || tx.TransactionType == TransactionType.Capture))
{
totalCaptures += tx.Amount;
}
}
totalCaptures += transaction.Amount;
payment.Amount = totalCaptures;
}
else
{
//THIS IS A PARTIAL CAPTURE
transaction.TransactionType = TransactionType.PartialCapture;
//LEAVE PAYMENT AMOUNT ALONE (AMOUNT OF AUTHORIZATION)
}
//UPDATE PAYMENT DETAILS
payment.PaymentDate = transaction.TransactionDate;
payment.PaymentStatus = (remainingSettle == 0) ? PaymentStatus.Captured : PaymentStatus.Authorized;
payment.PaymentStatusReason = string.Empty;
//ADD IN TRANSACTION IF NEEDED
if (transaction.TransactionId == 0)
{
payment.Transactions.Add(transaction);
}
break;
case "REFUNDED":
case "REVERSED":
//GET THE REFUND AMOUNT
LSDecimal refundAmount = Math.Abs(AlwaysConvert.ToDecimal(IpnProcessor.GetFormValue(request.Form, "mc_gross")));
//TRY TO LOCATE THE CORRECT PAYMENT BASED ON CAPTURE TRANSACITON ID
payment = FindPayPalPayment(paypalGateway.PaymentGatewayId, orderPayments, IpnProcessor.GetFormValue(request.Form, "parent_txn_id"));
if (payment == null)
{
//SEE IF WE CAN FIND THE PAYMENT VIA AUTH TRANSACTION ID
payment = FindPayPalPayment(paypalGateway.PaymentGatewayId, orderPayments, IpnProcessor.GetFormValue(request.Form, "auth_id"));
}
//CREATE A REFUND TRANSACTION
transaction = new Transaction();
//CREATE A PAYMENT IF AN EXISTING ONE WAS NOT FOUND
if (payment == null)
{
payment = new Payment();
payment.OrderId = orderId;
payment.PaymentMethodId = paypalMethod.PaymentMethodId;
payment.PaymentMethodName = paypalMethod.Name;
payment.Amount = -1 * refundAmount;
transaction.TransactionType = TransactionType.Refund;
order.Payments.Add(payment);
}
else
{
if (payment.Amount == refundAmount)
{
//FULL REFUND
transaction.TransactionType = TransactionType.Refund;
payment.PaymentStatus = PaymentStatus.Refunded;
}
else
{
//PARTIAL REFUND
transaction.TransactionType = TransactionType.PartialRefund;
payment.Amount -= refundAmount;
payment.PaymentStatus = PaymentStatus.Captured;
}
}
transaction.PaymentGatewayId = paypalGateway.PaymentGatewayId;
transaction.ProviderTransactionId = IpnProcessor.GetFormValue(request.Form, "txn_id");
transaction.TransactionDate = AlwaysConvert.ToDateTime(request.Form["payment_date"], DateTime.UtcNow).ToUniversalTime();
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.AuthorizationCode = IpnProcessor.GetFormValue(request.Form, "auth_id");
transaction.RemoteIP = IpnProcessor.GetFormValue(request.ServerVariables, "REMOTE_ADDR");
transaction.Referrer = IpnProcessor.GetFormValue(request.ServerVariables, "HTTP_REFERER");
transaction.Amount = refundAmount;
string responseMessage = IpnProcessor.GetFormValue(request.Form, "reason_code");
if (responseMessage != "refund")
{
transaction.ResponseCode = paymentStatus;
transaction.ResponseMessage = responseMessage;
}
//UPDATE PAYMENT DETAILS
payment.PaymentDate = transaction.TransactionDate;
payment.PaymentStatusReason = string.Empty;
//ADD IN TRANSACTION
payment.Transactions.Add(transaction);
break;
case "VOIDED":
//SEE IF WE CAN FIND THE PAYMENT VIA AUTH TRANSACTION ID
payment = FindPayPalPayment(paypalGateway.PaymentGatewayId, orderPayments, IpnProcessor.GetFormValue(request.Form, "auth_id"));
//WE ONLY NEED TO CONTINUE IF A PAYMENT TO VOID WAS FOUND
if (payment != null)
{
//PAYPAL DOES NOT SEND THE AMOUNT OF THE VOID
//SO IF THIS PAYMENT WAS PARTIALLY CAPTURED, WE NEED TO KNOW HOW MUCH TO VOID
LSDecimal remainingAuthorization = payment.Transactions.GetRemainingAuthorized();
if (remainingAuthorization > 0)
{
//CREATE A VOID TRANSACTION
transaction = new Transaction();
transaction.TransactionType = TransactionType.Void;
transaction.Amount = remainingAuthorization;
transaction.PaymentGatewayId = paypalGateway.PaymentGatewayId;
transaction.ProviderTransactionId = IpnProcessor.GetFormValue(request.Form, "txn_id");
transaction.TransactionDate = AlwaysConvert.ToDateTime(request.Form["payment_date"], DateTime.UtcNow).ToUniversalTime();
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.AuthorizationCode = IpnProcessor.GetFormValue(request.Form, "auth_id");
transaction.RemoteIP = IpnProcessor.GetFormValue(request.ServerVariables, "REMOTE_ADDR");
transaction.Referrer = IpnProcessor.GetFormValue(request.ServerVariables, "HTTP_REFERER");
//UPDATE PAYMENT DETAILS
payment.PaymentDate = transaction.TransactionDate;
payment.PaymentStatusReason = string.Empty;
if (payment.Amount == remainingAuthorization)
{
//FULL VOID, CHANGE PAYMENT STATUS TO VOID
payment.PaymentStatus = PaymentStatus.Void;
}
else
{
//PARTIAL VOID, REDUCE PAYMENT AMOUNT BY VOID
payment.Amount -= remainingAuthorization;
//PAYMENT HAS NO REMAINING AUTHORIZATION AND SO IT IS CAPTURED
payment.PaymentStatus = PaymentStatus.Captured;
}
//ADD IN TRANSACTION
payment.Transactions.Add(transaction);
}
}
break;
case "FAILED":
//THIS IS A FAILED E-CHECK
//PENDINGTRANSACTION SHOULD HAVE BEEN OBTAINED ABOVE
if (payment != null && pendingTransaction != null)
{
pendingTransaction.TransactionStatus = TransactionStatus.Failed;
//MAKE SURE TO CLEAR OUT PENDING RESPONSECODE
pendingTransaction.ResponseCode = string.Empty;
//GET THE CURRENT TRANSACTION DATE
pendingTransaction.TransactionDate = AlwaysConvert.ToDateTime(request.Form["payment_date"], DateTime.UtcNow).ToUniversalTime();
//UPDATE PAYMENT DETAILS
payment.PaymentDate = pendingTransaction.TransactionDate;
payment.PaymentStatus = (IsVoidableFailure(payment) ? PaymentStatus.Void : PaymentStatus.CaptureFailed);
payment.PaymentStatusReason = string.Empty;
//SAVE PAYMENT (AND CHILD TRANSACTIONS)
payment.Save();
}
break;
default:
Logger.Warn("PayPal IPN transaction " + paypalTransactionId + " with a \"" + paymentStatus + "\" status was unhandled.");
break;
}
//IF PAYMENT IS SET, SAVE UPDATES
if (payment != null)
{
payment.Save();
}
}
response.Redirect(redirectUrl);
}
protected void Page_Load(object sender, EventArgs e)
{
_UserId = AlwaysConvert.ToInt(Request.QueryString["UserId"]);
OrderGrid.DataSource = OrderDataSource.LoadForUser(_UserId, "OrderDate DESC");
OrderGrid.DataBind();
}
protected void BatchButton_Click(object sender, EventArgs e)
{
List <string> messages = new List <string>();
List <int> orderIds = GetSelectedOrderIds();
if (orderIds.Count > 0)
{
if (BatchAction.SelectedValue.StartsWith("OS_"))
{
//UPDATE ORDER STATUS REQUESTED
int orderStatusId = AlwaysConvert.ToInt(BatchAction.SelectedValue.Substring(3));
//VALIDATE STATUS
OrderStatus status = OrderStatusDataSource.Load(orderStatusId);
if (status != null)
{
IDatabaseSessionManager database = AbleContext.Current.Database;
database.BeginTransaction();
foreach (int orderId in orderIds)
{
Order order = OrderDataSource.Load(orderId);
if (order != null)
{
order.UpdateOrderStatus(status);
}
}
database.CommitTransaction();
}
}
else
{
switch (BatchAction.SelectedValue)
{
case "INVOICE":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("Print/Invoices.aspx");
break;
case "PACKSLIP":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("Print/PackSlips.aspx");
break;
case "PULLSHEET":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("Print/PullSheet.aspx");
break;
case "CANCEL":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("Batch/Cancel.aspx");
break;
case "SHIPOPT":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("Batch/Ship.aspx");
break;
case "SHIP":
AbleContext.Current.Database.BeginTransaction();
int shipCount = 0;
foreach (int orderId in orderIds)
{
Order order = OrderDataSource.Load(orderId);
if (order != null && order.Shipments != null)
{
bool shipped = false;
int shipmentCount = order.Shipments.Count;
for (int i = 0; i < shipmentCount; i++)
{
OrderShipment shipment = order.Shipments[i];
if (shipment != null && !shipment.IsShipped)
{
shipment.Ship();
shipped = true;
}
}
if (shipped)
{
messages.Add("Order #" + order.OrderNumber + " shipped.");
shipCount++;
}
else
{
messages.Add("Order #" + order.OrderNumber + " did not have any unshipped items.");
}
}
}
AbleContext.Current.Database.CommitTransaction();
messages.Add(shipCount + " orders shipped.");
break;
case "PAY":
AbleContext.Current.Database.BeginTransaction();
int payCount = 0;
foreach (int orderId in orderIds)
{
Order order = OrderDataSource.Load(orderId);
if (order != null)
{
bool paid = false;
int paymentCount = order.Payments.Count;
for (int i = 0; i < paymentCount; i++)
{
Payment payment = order.Payments[i];
if (payment.PaymentStatus == PaymentStatus.Authorized)
{
payment.Capture(payment.Amount, true);
paid = true;
}
else if (payment.PaymentStatus == PaymentStatus.Unprocessed)
{
payment.Authorize();
paid = true;
}
}
if (paid)
{
payCount++;
messages.Add("Order " + order.OrderNumber.ToString() + " processed.");
}
else
{
messages.Add("Order " + order.OrderNumber.ToString() + " does not have any payments to be processed.");
}
}
}
AbleContext.Current.Database.CommitTransaction();
messages.Add(payCount + " orders processed.");
break;
case "DELETE":
if (AbleContext.Current.User.IsSystemAdmin)
{
IDatabaseSessionManager database = AbleContext.Current.Database;
database.BeginTransaction();
foreach (int orderId in orderIds)
{
OrderDataSource.Delete(orderId);
}
database.CommitTransaction();
OrderGrid.DataBind();
}
break;
case "EXPORT":
AbleContext.Current.Session.SelectedOrderIds = orderIds;
Response.Redirect("../DataExchange/OrdersExport.aspx?type=selected");
break;
}
}
}
if (messages.Count > 0)
{
BatchMessage.Visible = true;
BatchMessage.Text = string.Join("<br />", messages.ToArray());
}
BatchAction.SelectedIndex = -1;
OrderGrid.DataBind();
}
private void ProcessRules(BreadCrumbItem breadCrumbItem)
{
int id;
if (breadCrumbItem.Url == "#")
{
return;
}
switch (breadCrumbItem.Url.ToLowerInvariant())
{
case "~/admin/orders/shipments/editshipment.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["OrderShipmentId"]);
breadCrumbItem.Url += "?OrderShipmentId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, id);
break;
case "~/admin/products/editproduct.aspx":
case "~/admin/products/variants/variants.aspx":
case "~/admin/products/variants/options.aspx":
case "~/admin/products/digitalgoods/digitalgoods.aspx":
case "~/admin/products/kits/editkit.aspx":
case "~/admin/products/assets/images.aspx":
case "~/admin/products/editproducttemplate.aspx":
case "~/admin/products/specials/default.aspx":
int categoryId = AbleCommerce.Code.PageHelper.GetCategoryId();
id = AbleCommerce.Code.PageHelper.GetProductId();
Product product = ProductDataSource.Load(id);
if (categoryId > 0)
{
breadCrumbItem.Url += "?CategoryId=" + categoryId + "&ProductId=" + id;
}
else
{
breadCrumbItem.Url += "?ProductId=" + id;
}
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, product.Name);
break;
case "~/admin/orders/vieworder.aspx":
case "~/admin/orders/edit/editorderitems.aspx":
case "~/admin/orders/viewdigitalgoods.aspx":
case "~/admin/orders/payments/default.aspx":
case "~/admin/orders/shipments/default.aspx":
id = AbleCommerce.Code.PageHelper.GetOrderId();
Order order = OrderDataSource.Load(id);
breadCrumbItem.Url += "?OrderNumber=" + order.OrderNumber;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, order.OrderNumber);
break;
case "~/admin/marketing/coupons/editcoupon.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["CouponId"]);
Coupon coupon = CouponDataSource.Load(id);
breadCrumbItem.Url += "?CouponId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, coupon.Name);
break;
case "~/admin/products/variants/editoption.aspx":
case "~/admin/products/variants/editchoices.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["OptionId"]);
Option option = OptionDataSource.Load(id);
breadCrumbItem.Url += "?OptionId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, option.Name);
break;
case "~/admin/products/giftwrap/editwrapgroup.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["WrapGroupId"]);
WrapGroup wrapGroup = WrapGroupDataSource.Load(id);
breadCrumbItem.Url += "?WrapGroupId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, wrapGroup.Name);
break;
case "~/admin/marketing/email/managelist.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["EmailListId"]);
EmailList emailList = EmailListDataSource.Load(id);
if (emailList != null)
{
breadCrumbItem.Url += "?EmailListId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, emailList.Name);
}
break;
case "~/admin/marketing/discounts/editdiscount.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["VolumeDiscountId"]);
VolumeDiscount discount = VolumeDiscountDataSource.Load(id);
breadCrumbItem.Url += "?VolumeDiscountId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, discount.Name);
break;
case "~/admin/catalog/editwebpage.aspx":
id = AbleCommerce.Code.PageHelper.GetWebpageId();
Webpage webpage = WebpageDataSource.Load(id);
breadCrumbItem.Url += "?WebpageId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, webpage.Name);
break;
case "~/admin/catalog/editLink.aspx":
id = AbleCommerce.Code.PageHelper.GetLinkId();
Link link = LinkDataSource.Load(id);
breadCrumbItem.Url += "?LinkId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, link.Name);
break;
case "~/admin/people/users/edituser.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["UserId"]);
User user = UserDataSource.Load(id);
breadCrumbItem.Url += "?UserId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, user.UserName);
break;
case "~/admin/digitalgoods/editdigitalgood.aspx":
case "~/admin/digitalgoods/serialkeyproviders/defaultprovider/configure.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["DigitalGoodId"]);
DigitalGood dg = DigitalGoodDataSource.Load(id);
if (dg != null)
{
breadCrumbItem.Url += "?DigitalGoodId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, dg.Name);
}
break;
case "~/admin/products/producttemplates/editproducttemplate.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["ProductTemplateId"]);
ProductTemplate template = ProductTemplateDataSource.Load(id);
if (template == null)
{
InputField field = InputFieldDataSource.Load(AlwaysConvert.ToInt(Request.QueryString["InputFieldId"]));
if (field != null)
{
template = field.ProductTemplate;
id = template.Id;
}
}
if (template != null)
{
breadCrumbItem.Url += "?ProductTemplateId=" + id;
breadCrumbItem.Title = string.Format(breadCrumbItem.Title, template.Name);
}
else
{
}
break;
case "~/admin/reports/dailyabandonedbaskets.aspx":
id = AlwaysConvert.ToInt(Request.QueryString["BasketId"]);
Basket basket = BasketDataSource.Load(id);
if (basket != null)
{
breadCrumbItem.Url += "?ReportDate=" + basket.User.LastActivityDate.Value.ToShortDateString();
}
break;
}
// resolve relative urls
if (breadCrumbItem.Url.StartsWith("~/"))
{
breadCrumbItem.Url = Page.ResolveUrl(breadCrumbItem.Url);
}
}
protected IList <Order> GetCouponOrders(object dataItem)
{
CouponSummary summary = (CouponSummary)dataItem;
return(OrderDataSource.LoadForCouponCode(summary.CouponCode, summary.StartDate, summary.EndDate, "O.Id ASC"));
}
public ExpressCheckoutResult DoExpressCheckout()
{
HttpContext context = HttpContext.Current;
TraceContext trace = context.Trace;
string traceCategory = this.GetType().ToString();
ExpressCheckoutSession paypalSession = ExpressCheckoutSession.Current;
if (paypalSession == null)
{
//EXIT WITH EXCEPTION
ErrorType[] customErrorList = new ErrorType[1];
ErrorType customError = new ErrorType();
customError.ErrorCode = "SESSION";
customError.ShortMessage = "Missing Token";
customError.LongMessage = "The PayPal session token was expired or unavailable. Please try again.";
customErrorList[0] = customError;
return(new ExpressCheckoutResult(0, string.Empty, customErrorList));
}
trace.Write(traceCategory, "Detected PayPal Token:" + paypalSession.Token);
trace.Write(traceCategory, "Token Expiration:" + paypalSession.TokenExpiration.ToLongDateString());
if (string.IsNullOrEmpty(paypalSession.PayerID))
{
//EXIT WITH EXCEPTION
ErrorType[] customErrorList = new ErrorType[1];
ErrorType customError = new ErrorType();
customError.ErrorCode = "SESSION";
customError.ShortMessage = "Missing Payer ID";
customError.LongMessage = "The PayPal Payer ID is not present.";
customErrorList[0] = customError;
return(new ExpressCheckoutResult(0, string.Empty, customErrorList));
}
trace.Write(traceCategory, "Detected PayPal Payer ID:" + paypalSession.PayerID);
//GET THE CURRENCY FOR THE TRANSACTION
string storeCurrencyCode = Token.Instance.Store.BaseCurrency.ISOCode;
CurrencyCodeType baseCurrencyCode = PayPalProvider.GetPayPalCurrencyType(storeCurrencyCode);
//CREATE THE EXPRESS CHECKOUT
DoExpressCheckoutPaymentRequestType expressCheckoutRequest = new DoExpressCheckoutPaymentRequestType();
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails = new DoExpressCheckoutPaymentRequestDetailsType();
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.Token = paypalSession.Token;
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PaymentAction = this.UseAuthCapture ? PaymentActionCodeType.Sale : PaymentActionCodeType.Authorization;
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PaymentActionSpecified = true;
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PayerID = paypalSession.PayerID;
expressCheckoutRequest.Version = "1.0";
//SET THE ORDER TOTAL AMOUNTS
Basket basket = Token.Instance.User.Basket;
trace.Write(traceCategory, "Set Order Totals");
LSDecimal curOrderTotal = basket.Items.TotalPrice();
LSDecimal curShippingTotal = basket.Items.TotalPrice(OrderItemType.Shipping) + GetShippingCouponTotal(basket.Items);
LSDecimal curHandlingTotal = basket.Items.TotalPrice(OrderItemType.Handling);
LSDecimal curTaxTotal = basket.Items.TotalPrice(OrderItemType.Tax);
LSDecimal curItemTotal = curOrderTotal - (curShippingTotal + curHandlingTotal + curTaxTotal);
//MAKE SURE OUR BREAKDOWN IS VALID
if ((curShippingTotal < 0) || (curHandlingTotal < 0) || (curTaxTotal < 0) || (curItemTotal < 0))
{
//THE BREAKDOWN IS INVALID, DO NOT INCLUDE IT IN THE REQUEST
curShippingTotal = 0;
curHandlingTotal = 0;
curTaxTotal = 0;
curItemTotal = curOrderTotal;
}
//SET THE PAYMENT DETAILS
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PaymentDetails = new PaymentDetailsType[1];
expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PaymentDetails[0] = new PaymentDetailsType();
PaymentDetailsType paymentDetails = expressCheckoutRequest.DoExpressCheckoutPaymentRequestDetails.PaymentDetails[0];
paymentDetails.OrderTotal = new BasicAmountType();
paymentDetails.OrderTotal.currencyID = baseCurrencyCode;
paymentDetails.OrderTotal.Value = string.Format("{0:##,##0.00}", curOrderTotal);
paymentDetails.ItemTotal = new BasicAmountType();
paymentDetails.ItemTotal.currencyID = baseCurrencyCode;
paymentDetails.ItemTotal.Value = string.Format("{0:##,##0.00}", curItemTotal);
paymentDetails.ShippingTotal = new BasicAmountType();
paymentDetails.ShippingTotal.currencyID = baseCurrencyCode;
paymentDetails.ShippingTotal.Value = string.Format("{0:##,##0.00}", curShippingTotal);
paymentDetails.HandlingTotal = new BasicAmountType();
paymentDetails.HandlingTotal.currencyID = baseCurrencyCode;
paymentDetails.HandlingTotal.Value = string.Format("{0:##,##0.00}", curHandlingTotal);
paymentDetails.TaxTotal = new BasicAmountType();
paymentDetails.TaxTotal.currencyID = baseCurrencyCode;
paymentDetails.TaxTotal.Value = string.Format("{0:##,##0.00}", curTaxTotal);
trace.Write(traceCategory, "Order Total: " + curOrderTotal);
trace.Write(traceCategory, "Item Total: " + curItemTotal);
trace.Write(traceCategory, "Shipping Total: " + curShippingTotal);
trace.Write(traceCategory, "Handling Total: " + curHandlingTotal);
trace.Write(traceCategory, "Tax Total: " + curTaxTotal);
//SET THE BUTTON SOURCE
trace.Write(traceCategory, "Set Button Source");
paymentDetails.ButtonSource = "ablecommerce-EC";
//SET THE NOTIFY URL
string notifyUrl = GetStoreUrl() + "/ProcessPayPal.ashx";
trace.Write(traceCategory, "IPN Callback URL: " + notifyUrl);
paymentDetails.NotifyURL = notifyUrl;
//WE HAVE ALL NECESSARY INFORMATION TO DO EXPRESS CHECKOUT
//COMMIT THE ORDER BEFORE SUBMITTING THE PAYPAL TRANSACTION
//CREATE THE ABLECOMMERCE PAYMENT ITEM
Payment checkoutPayment = new Payment();
checkoutPayment.PaymentMethodId = GetPayPalPaymentMethodId(false);
checkoutPayment.Amount = curOrderTotal;
checkoutPayment.CurrencyCode = baseCurrencyCode.ToString();
//AT THIS POINT, EXECUTE THE CHECKOUT TO SUBMIT THE ORDER
CheckoutRequest checkoutRequest = new CheckoutRequest(checkoutPayment);
CheckoutResponse checkoutResponse = basket.Checkout(checkoutRequest);
int orderId = checkoutResponse.OrderId;
//LOAD THE ORDER AND RE-OBTAIN THE PAYMENT RECORD TO AVOID DATA INCONSISTENCIES
Order order = OrderDataSource.Load(orderId);
if (order == null)
{
//EXIT WITH EXCEPTION
ErrorType[] customErrorList = new ErrorType[1];
ErrorType customError = new ErrorType();
customError.ErrorCode = "ORDER";
customError.ShortMessage = "Your order could not be completed at this time.";
customError.LongMessage = "Your order could not be completed at this time and payment was not processed. " + string.Join(" ", checkoutResponse.WarningMessages.ToArray());
customErrorList[0] = customError;
return(new ExpressCheckoutResult(0, string.Empty, customErrorList));
}
int findPaymentId = checkoutPayment.PaymentId;
foreach (Payment payment in order.Payments)
{
if (payment.PaymentId == findPaymentId)
{
checkoutPayment = payment;
}
}
//SET THE DESCRIPTION
paymentDetails.OrderDescription = "Order #" + order.OrderNumber.ToString();
paymentDetails.Custom = orderId.ToString();
//EXECUTE PAYPAL REQUEST
trace.Write(traceCategory, "Do Request");
DoExpressCheckoutPaymentResponseType expressCheckoutResponse = (DoExpressCheckoutPaymentResponseType)SoapCall("DoExpressCheckoutPayment", expressCheckoutRequest);
ErrorType[] responseErrors = null;
PaymentStatus finalPaymentStatus = PaymentStatus.Unprocessed;
bool isPendingeCheck = false;
if (expressCheckoutResponse != null)
{
if (expressCheckoutResponse.Errors == null)
{
//CREATE THE PAYPAL TRANSACTION RECORD
Transaction checkoutTransaction = new Transaction();
PaymentInfoType paymentInfo = expressCheckoutResponse.DoExpressCheckoutPaymentResponseDetails.PaymentInfo[0];
isPendingeCheck = (paymentInfo.PaymentStatus == PaymentStatusCodeType.Pending && paymentInfo.PendingReason == PendingStatusCodeType.echeck);
PaymentStatusCodeType paymentStatus = paymentInfo.PaymentStatus;
switch (paymentStatus)
{
case PaymentStatusCodeType.Completed:
case PaymentStatusCodeType.Processed:
case PaymentStatusCodeType.Pending:
if (isPendingeCheck)
{
finalPaymentStatus = PaymentStatus.CapturePending;
checkoutTransaction.ResponseCode = "PENDING";
checkoutTransaction.ResponseMessage = "echeck";
}
else
{
finalPaymentStatus = (paymentStatus != PaymentStatusCodeType.Pending) ? PaymentStatus.Captured : PaymentStatus.Authorized;
}
checkoutTransaction.TransactionStatus = TransactionStatus.Successful;
break;
default:
finalPaymentStatus = PaymentStatus.Unprocessed;
checkoutTransaction.TransactionStatus = TransactionStatus.Failed;
checkoutTransaction.ResponseCode = expressCheckoutResponse.Ack.ToString();
checkoutTransaction.ResponseMessage = paymentStatus.ToString().ToUpperInvariant();
break;
}
checkoutTransaction.TransactionType = this.UseAuthCapture ? TransactionType.Capture : TransactionType.Authorize;
checkoutTransaction.Amount = AlwaysConvert.ToDecimal(paymentInfo.GrossAmount.Value, (Decimal)curOrderTotal);
checkoutTransaction.AuthorizationCode = paymentInfo.TransactionID;
checkoutTransaction.AVSResultCode = "U";
checkoutTransaction.ProviderTransactionId = paymentInfo.TransactionID;
checkoutTransaction.Referrer = context.Request.ServerVariables["HTTP_REFERER"];
checkoutTransaction.PaymentGatewayId = this.PaymentGatewayId;
checkoutTransaction.RemoteIP = context.Request.ServerVariables["REMOTE_ADDR"];
checkoutPayment.Transactions.Add(checkoutTransaction);
//FIND THE WAITING FOR IPN TRANSACTION AND REMOVE
int i = checkoutPayment.Transactions.Count - 1;
while (i >= 0)
{
if (string.IsNullOrEmpty(checkoutPayment.Transactions[i].AuthorizationCode))
{
checkoutPayment.Transactions.DeleteAt(i);
}
i--;
}
}
else
{
//SOME SORT OF ERROR ATTEMPTING CHECKOUT
responseErrors = expressCheckoutResponse.Errors;
}
}
else
{
//NO RESPONSE, GENERATE CUSTOM ERROR
responseErrors = new ErrorType[1];
ErrorType customError = new ErrorType();
customError.ErrorCode = "NORESP";
customError.ShortMessage = "No Response From Server";
customError.LongMessage = "The PayPal service is unavailable at this time.";
responseErrors[0] = customError;
}
trace.Write(traceCategory, "Do Request Done");
//ERRORS IN RESPONSE?
if ((responseErrors != null) && (responseErrors.Length > 0))
{
//CREATE THE PAYPAL TRANSACTION RECORD FOR ERROR
Transaction checkoutTransaction = new Transaction();
finalPaymentStatus = PaymentStatus.Unprocessed;
checkoutTransaction.TransactionStatus = TransactionStatus.Failed;
checkoutTransaction.Amount = curOrderTotal;
checkoutTransaction.AuthorizationCode = string.Empty;
checkoutTransaction.Referrer = context.Request.ServerVariables["HTTP_REFERER"];
checkoutTransaction.PaymentGatewayId = this.PaymentGatewayId;
checkoutTransaction.RemoteIP = context.Request.ServerVariables["REMOTE_ADDR"];
checkoutTransaction.ResponseCode = responseErrors[0].ShortMessage;
checkoutTransaction.ResponseMessage = responseErrors[0].LongMessage;
checkoutPayment.Transactions.Add(checkoutTransaction);
}
//MAKE SURE PAYMENT STATUS IS CORRECT
checkoutPayment.ReferenceNumber = paypalSession.Payer;
checkoutPayment.PaymentStatus = finalPaymentStatus;
if (isPendingeCheck)
{
checkoutPayment.PaymentStatusReason = "echeck";
}
//RECALCULATE THE ORDER STATUS (BUG 6384) AND TRIGGER PAYMENT EVENTS (BUG 8650)
order.Save(true, true);
//CLEAR THE TOKENS SET IN SESSION
paypalSession.Delete();
return(new ExpressCheckoutResult(orderId, string.Empty, responseErrors));
}
protected void ChangeShipMethodOKButton_Click(object source, EventArgs e)
{
int shipmentId = AlwaysConvert.ToInt(Request.Form[ChangeShipMethodShipmentId.UniqueID]);
int index = _Order.Shipments.IndexOf(shipmentId);
if (index > -1)
{
// WE FOUND THE TARGET SHIPMENT. REMOVE OLD SHIPPING LINE ITEMS
OrderShipment shipment = _Order.Shipments[index];
for (int i = shipment.OrderItems.Count - 1; i >= 0; i--)
{
OrderItemType itemType = shipment.OrderItems[i].OrderItemType;
if (itemType == OrderItemType.Shipping || itemType == OrderItemType.Handling)
{
shipment.OrderItems.DeleteAt(i);
}
}
// SEE IF WE HAVE A NEW SELECTED SHIPMETHOD
int shipMethodId = AlwaysConvert.ToInt(Request.Form[NewShipMethod.UniqueID]);
ShipMethod shipMethod = ShipMethodDataSource.Load(shipMethodId);
if (shipMethod != null)
{
ShipRateQuote rate = shipMethod.GetShipRateQuote(shipment);
if (rate != null)
{
// ADD NEW SHIPPING LINE ITEMS TO THE ORDER
OrderItem shipRateLineItem = new OrderItem();
shipRateLineItem.OrderId = _Order.Id;
shipRateLineItem.OrderItemType = OrderItemType.Shipping;
shipRateLineItem.OrderShipmentId = shipmentId;
shipRateLineItem.Name = shipMethod.Name;
shipRateLineItem.Price = rate.Rate;
shipRateLineItem.Quantity = 1;
shipRateLineItem.TaxCodeId = shipMethod.TaxCodeId;
shipRateLineItem.Save();
shipment.OrderItems.Add(shipRateLineItem);
if (rate.Surcharge > 0)
{
shipRateLineItem = new OrderItem();
shipRateLineItem.OrderId = _Order.Id;
shipRateLineItem.OrderItemType = OrderItemType.Handling;
shipRateLineItem.OrderShipmentId = shipmentId;
shipRateLineItem.Name = shipMethod.Name;
shipRateLineItem.Price = rate.Surcharge;
shipRateLineItem.Quantity = 1;
shipRateLineItem.TaxCodeId = shipMethod.TaxCodeId;
shipRateLineItem.Save();
shipment.OrderItems.Add(shipRateLineItem);
}
//Add the Tracking Number
ShipGateway shipGateway = shipMethod.ShipGateway;
foreach (TrackingNumber tn in shipment.TrackingNumbers)
{
tn.ShipGateway = shipGateway;
}
}
}
// UPDATE THE SHIPMENT WITH NEW METHOD ASSOCIATION
shipment.ShipMethodId = shipMethodId;
shipment.ShipMethodName = (shipMethod != null ? shipMethod.Name : string.Empty);
shipment.Save();
// RELOAD ORDER AND REBIND THE PAGE FOR UPDATED INFO
_Order = OrderDataSource.Load(_Order.Id);
BindShipmentsGrid();
}
}
protected void MailButton_Click(object sender, EventArgs e)
{
// CREATE THE PAYMENT OBJECT
Payment payment = GetPayment();
// PROCESS CHECKING OUT EVENT
bool checkOut = true;
if (CheckingOut != null)
{
CheckingOutEventArgs c = new CheckingOutEventArgs(payment);
CheckingOut(this, c);
checkOut = !c.Cancel;
}
if (checkOut)
{
// CONTINUE TO PROCESS THE CHECKOUT
Basket basket = AbleContext.Current.User.Basket;
//Remove code?
//ICheckoutService checkoutService = AbleContext.Resolve<ICheckoutService>();
//CheckoutRequest checkoutRequest = new CheckoutRequest(basket, payment);
//CheckoutResponse checkoutResponse = checkoutService.ExecuteCheckout(checkoutRequest);
//CUSTOM: PROCESS THE CHECKOUT
CheckoutRequest checkoutRequest = new CheckoutRequest(null);
CheckoutResponse checkoutResponse = basket.Checkout(checkoutRequest);
if (checkoutResponse.Success)
{
Order order = new Order();
order = OrderDataSource.Load(checkoutResponse.OrderId);
Address address = AbleContext.Current.User.PrimaryAddress;
// Add the contact details to the saved order.
order.BillToEmail = address.Email;
order.BillToFirstName = address.FirstName;
order.BillToLastName = address.LastName;
order.BillToPhone = address.Phone;
order.BillToCompany = address.Company;
order.Save();
// Save the Comment entered on the Quote Form to the CustomFields table.
CustomField comment = new CustomField();
comment.FieldName = "QuoteRequestComment";
comment.FieldValue = Comments.Text;
comment.TableName = "Orders";
comment.ForeignKeyId = order.Id;
comment.Store.Id = order.StoreId;
comment.Save();
// The list of files that have been uploaded
List <FileAttachment> files = Session["UPLOADED_BASKET"] as List <FileAttachment>;
//CrmHelper.SaveEnquiry(order, StringHelper.StripHtml(Comments.Text), files, AbleContext.Current.Store);
if (checkoutResponse.Success)
{
if (CheckedOut != null)
{
CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
}
Response.Redirect(AbleCommerce.Code.NavigationHelper.GetReceiptUrl(checkoutResponse.Order.OrderNumber));
}
else
{
IList <string> warningMessages = checkoutResponse.WarningMessages;
if (warningMessages.Count == 0)
{
warningMessages.Add("The order could not be submitted at this time. Please try again later or contact us for assistance.");
}
if (CheckedOut != null)
{
CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
}
}
}
}
}
private void BindOrderSummaryGrid(DateTime lastDayStart)
{
OrderSummaryGrid.DataSource = OrderDataSource.LoadOrderStatusSummaries(lastDayStart);
OrderSummaryGrid.DataBind();
}
protected int GetOrderCount(object dataItem)
{
Affiliate a = (Affiliate)dataItem;
return(OrderDataSource.CountForAffiliate(a.Id));
}
){kind=link}
){kind=link}
){kind=link}
){kind=link}