private static LSDecimal CalculateTax(TaxRule taxRule, LSDecimal price)
{
// DETERMINE TAX FOR TOTAL PRICE
LSDecimal tempTax = ((price * taxRule.TaxRate) / 100);
return(TaxHelper.Round((decimal)tempTax, 2, taxRule.RoundingRule));
}
/// <summary>
/// Calculates tax
/// </summary>
/// <param name="taxRule">The tax rule to process</param>
/// <param name="order">The order being processed</param>
/// <param name="shipmentId">The shipment ID to calculate tax for; pass 0 for unshippable or -1 to ignore shipments</param>
/// <returns>A basket item for the tax entry, or null if no tax is charged.</returns>
public static OrderItem Calculate(TaxRule taxRule, Order order, int shipmentId)
{
//THIS SHIPMENT QUALIFIES, GET TOTAL OF ALL APPLICABLE BASKET ITEMS
LSDecimal totalPrice = 0;
foreach (OrderItem oi in order.Items)
{
//CHECK IF THE ITEM IS PART OF THE SHIPMENT
if (oi.OrderShipmentId == shipmentId || shipmentId < 0)
{
//CHECK WHETHER THE TAX CODE IS AFFECTED BY THIS Tax RULE
if (taxRule.AppliesToTaxCode(oi.TaxCodeId))
{
totalPrice += oi.ExtendedPrice;
}
}
}
// GENERATE ITEM AND RETURN IF VALID
OrderItem taxItem = GenerateOrderItem(order.OrderId, shipmentId, taxRule, totalPrice);
if (taxItem.ExtendedPrice > 0)
{
return(taxItem);
}
return(null);
}
public LSDecimal CalculateValue(LSDecimal itemTotal)
{
// WE DO NOT NEED TO CALCULATE COUPONS FOR NON-POSITIVE VALUES
if (itemTotal <= 0)
{
return(0);
}
// DETERMINE THE COUPON VALUE
LSDecimal couponValue;
if (this.IsPercent)
{
couponValue = Math.Round(((decimal)itemTotal * (decimal)this.DiscountAmount) / 100, 2, MidpointRounding.AwayFromZero);
}
else
{
couponValue = this.DiscountAmount;
}
if (couponValue > itemTotal)
{
couponValue = itemTotal;
}
if (this.MaxValue > 0 && couponValue > this.MaxValue)
{
couponValue = this.MaxValue;
}
return(-1 * couponValue);
}
private CreditCardRequest InitializeRefundRequest(Payment payment, Transaction captureTransaction, LSDecimal amount)
{
VerifyPaymentInstrument(payment);
CreditCardRequest request = new CreditCardRequest();
request.setChargeType(CreditCardRequest.CREDIT);
request.setReferenceId(captureTransaction.ProviderTransactionId);
request.setOrderId(payment.Order.OrderId.ToString());
LSDecimal minAmount = 0.01M;
if (amount > captureTransaction.Amount || amount < minAmount)
{
throw new InvalidOperationException("Refund Amount must be from 0.01 to the previously captured amount");
}
request.setChargeTotal((double)amount);
AccountDataDictionary accountData = new AccountDataDictionary(payment.AccountData);
SetCreditCardData(request, payment, accountData);
if (!string.IsNullOrEmpty(payment.CurrencyCode))
{
request.setCurrency(payment.CurrencyCode);
}
return(request);
}
public DiscountedBasketProduct(int productId, LSDecimal averagePrice, int quantity)
{
_ProductId = productId;
_AveragePrice = averagePrice;
_Quantity = quantity;
_ExtendedPrice = _AveragePrice * Quantity;
}
private Dictionary <string, ProviderShipRateQuote> ParseProviderRateReponseIntl(XmlDocument providerResponse, Package[] packageList)
{
//CREATE TEMPORARY STORAGE FOR PARSING THE QUOTED SERVICES
Dictionary <string, ProviderShipRateQuote> availableServices = new Dictionary <string, ProviderShipRateQuote>();
ProviderShipRateQuote serviceQuote;
//LOOP EACH PACKAGE IN THE RESPONSE
XmlNodeList packageNodeList = providerResponse.DocumentElement.SelectNodes("Package");
foreach (XmlNode packageNode in packageNodeList)
{
XmlNodeList serviceNodeList = packageNode.SelectNodes("Service");
foreach (XmlNode serviceNode in serviceNodeList)
{
string serviceName = XmlUtility.GetElementValue(serviceNode, "SvcDescription", string.Empty);
LSDecimal postage = AlwaysConvert.ToDecimal(XmlUtility.GetElementValue(serviceNode, "Postage", string.Empty));
if (postage > 0)
{
//GET THE INSTANCE OF SERVICEQUOTE TO BE UPDATED
if (availableServices.ContainsKey(serviceName))
{
serviceQuote = availableServices[serviceName];
}
else
{
//CREATE A NEW INSTANCE OF ProviderShipRateQuote
serviceQuote = new ProviderShipRateQuote();
serviceQuote.ServiceCode = serviceName;
availableServices.Add(serviceName, serviceQuote);
}
//GET THE PACKAGE ID FROM THE RATE
int packageId = AlwaysConvert.ToInt(XmlUtility.GetAttributeValue(packageNode, "ID", string.Empty), -1);
if (packageId != -1)
{
//FIND THE PACKAGE IN THE LIST
Package package = packageList[packageId];
serviceQuote.Rate += (postage * package.Multiplier);
serviceQuote.PackageCount += 1;
}
}
}
}
//MOVE THROUGH LIST AND FIND SERVICES THAT ARE NOT AVAILABLE
//FOR ALL PACKAGES IN THE SHIPMENT
List <string> removeServices = new List <string>();
foreach (string serviceName in availableServices.Keys)
{
serviceQuote = availableServices[serviceName];
if (serviceQuote.PackageCount < packageList.Length)
{
removeServices.Add(serviceName);
}
}
//REMOVE ANY SERVICES THAT WERE IDENTIFIED
foreach (string serviceName in removeServices)
{
availableServices.Remove(serviceName);
}
return(availableServices);
}
private Transaction ProcessRecurringResponse(AuthorizeRecurringTransactionRequest authRequest, RecurringResponse response)
{
//CREATE THE TRANSACTION OBJECT
Transaction transaction = new Transaction();
transaction.PaymentGatewayId = this.PaymentGatewayId;
transaction.TransactionType = TransactionType.AuthorizeRecurring;
LSDecimal transAmount = authRequest.RecurringChargeSpecified ? authRequest.RecurringCharge : authRequest.Amount;
transaction.Amount = transAmount;
if (response.getResponseCode() != 1)
{
transaction.TransactionStatus = TransactionStatus.Failed;
transaction.ResponseCode = response.getResponseCode().ToString();
transaction.ResponseMessage = response.getResponseCodeText();
}
else
{
transaction.TransactionStatus = TransactionStatus.Successful;
//transaction.ProviderTransactionId = response.getReferenceId();
transaction.TransactionDate = response.getTimeStamp();
transaction.ResponseCode = response.getResponseCode().ToString();
transaction.ResponseMessage = response.getResponseCodeText();
HttpContext context = HttpContext.Current;
if (context != null)
{
transaction.RemoteIP = context.Request.ServerVariables["REMOTE_ADDR"];
transaction.Referrer = context.Request.ServerVariables["HTTP_REFERER"];
}
}
return(transaction);
}
/// <summary>
/// Processes a partial capture event
/// </summary>
/// <param name="payment">The payment that is captured</param>
/// <param name="captureAmount">The amount that is captured</param>
public static void PaymentCapturedPartial(Payment payment, LSDecimal captureAmount)
{
Order order = payment.Order;
order.Notes.Add(new OrderNote(order.OrderId, order.UserId, LocaleHelper.LocalNow, string.Format(Properties.Resources.PaymentCapturedPartial, captureAmount), NoteType.SystemPrivate));
order.Notes.Save();
UpdateOrderStatus(StoreEvent.PaymentCapturedPartial, order);
Hashtable parameters = new Hashtable();
parameters["order"] = order;
parameters["customer"] = order.User;
parameters["payment"] = payment;
ProcessEmails(StoreEvent.PaymentCapturedPartial, parameters);
//A PAYMENT HAS BEEN COMPLETED, SO DETERMINE WHICH ORDER PAID EVENT TO TRIGGER
LSDecimal balance = order.GetBalance(false);
if (balance == 0)
{
OrderPaid(order);
}
else if (balance > 0)
{
OrderPaidPartial(order, balance);
}
else
{
OrderPaidCreditBalance(order, balance);
}
}
private LSDecimal Calculate_PointOfDelivery(Basket basket, Dictionary <string, string> existingTransactions)
{
WebTrace.Write("CertiTAX: Begin Calculate POD");
LSDecimal totalTax = 0;
foreach (BasketShipment shipment in basket.Shipments)
{
CertiTAX.Order taxOrder = new CertiTAX.Order();
//SET THE TAXORDER ADDRESS
BuildTaxOrderAddress(taxOrder, shipment.Address);
//BUILD THE TAXORDER OBJECT
BuildTaxOrder(taxOrder, basket, shipment.BasketShipmentId, existingTransactions);
taxOrder.Nexus = "POD";
//EXECUTE THE TRANSACTION
CertiTAX.TaxTransaction taxTransaction = null;
try
{
taxTransaction = (new CertiTAX.CertiCalc()).Calculate(taxOrder);
}
catch (Exception ex)
{
WebTrace.Write("CertiTax could not calculate tax. The error was: " + ex.Message);
if (!this.IgnoreFailedConfirm)
{
throw;
}
}
//PARSE THE RESULTS
totalTax += ParseTaxTransaction(taxTransaction, basket, shipment.BasketShipmentId);
}
WebTrace.Write("CertiTAX: End Calculate POD");
//RETURN THE TOTAL TAX
return(totalTax);
}
/// <summary>
/// Gets the total value of refunded transactions in this collection
/// </summary>
/// <returns>The total value of refunded transactions in this collection</returns>
public LSDecimal GetTotalRefunded()
{
LSDecimal total = 0;
foreach (Transaction tx in this)
{
if (tx.TransactionStatus == TransactionStatus.Successful)
{
switch (tx.TransactionType)
{
case TransactionType.Authorize:
case TransactionType.AuthorizeCapture:
case TransactionType.PartialCapture:
case TransactionType.Capture:
case TransactionType.Void:
//do not include in total
break;
case TransactionType.PartialRefund:
case TransactionType.Refund:
//include in total
total += tx.Amount;
break;
default:
//THIS SHOULD NEVER HAPPEN IF ALL TRANSACTION TYPES ARE SPECIFIED ABOVE
throw new ArgumentOutOfRangeException("Invalid Transaction Type : " + tx.TransactionType.ToString());
}
}
}
return(total);
}
private Transaction ProcessRecurringResponse(AuthorizeRecurringTransactionRequest authRequest, string responseData)
{
//CREATE THE TRANSACTION OBJECT
Transaction transaction = new Transaction();
transaction.PaymentGatewayId = this.PaymentGatewayId;
transaction.TransactionType = TransactionType.AuthorizeRecurring;
LSDecimal transAmount = authRequest.RecurringChargeSpecified ? authRequest.RecurringCharge : authRequest.Amount;
transaction.Amount = transAmount;
NameValueCollection response = ParseResponseString(responseData);
int responseCode = AlwaysConvert.ToInt(response.Get("dc_response_code"), -9999);
if (responseCode == 0 || responseCode == 85)
{
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.ProviderTransactionId = response.Get("dc_transaction_id");
transaction.TransactionDate = LocaleHelper.LocalNow;
transaction.ResponseCode = response.Get("dc_response_code");
transaction.ResponseMessage = response.Get("dc_response_message");
}
else
{
transaction.TransactionStatus = TransactionStatus.Failed;
transaction.ResponseCode = response.Get("dc_response_code");
transaction.ResponseMessage = response.Get("dc_response_message");
}
return(transaction);
}
/// <summary>
/// Composes the Packages in this list in a way so that their maximum weight
/// does not exceed the given maximum value and is not below the given minimum value.
/// </summary>
/// <param name="maxWeight">The maximum weight that a Package should have</param>
/// <param name="minWeight">The minimum weight that a Package should have</param>
public void Compose(LSDecimal maxWeight, LSDecimal minWeight)
{
foreach (Package item in this)
{
item.Compose(maxWeight, minWeight);
}
}
private LSDecimal Calculate_PointOfSale(Basket basket, Dictionary <string, string> existingTransactions)
{
WebTrace.Write("CertiTAX: Begin Calculate POS");
CertiTAX.Order taxOrder = new CertiTAX.Order();
//SET THE TAXORDER ADDRESS
BuildTaxOrderAddress(taxOrder, StoreDataSource.Load().DefaultWarehouse);
//BUILD THE TAXORDER OBJECT
BuildTaxOrder(taxOrder, basket, 0, existingTransactions);
taxOrder.Nexus = "POS";
//EXECUTE THE TRANSACTION
CertiTAX.TaxTransaction taxTransaction = null;
try
{
taxTransaction = (new CertiTAX.CertiCalc()).Calculate(taxOrder);
}
catch (Exception ex)
{
WebTrace.Write("CertiTax could not calculate tax. The error was: " + ex.Message);
if (!this.IgnoreFailedConfirm)
{
throw;
}
}
//PARSE THE RESULTS
LSDecimal totalTax = ParseTaxTransaction(taxTransaction, basket, 0);
WebTrace.Write("CertiTAX: End Calculate POS");
return(totalTax);
}
/// <summary>
/// Converts dimensions of this package to the given measurement unit
/// </summary>
/// <param name="to">The measurement unit to convert to</param>
public void ConvertDimensions(MeasurementUnit to)
{
Height = LocaleHelper.ConvertMeasurement(this.MeasurementUnit, Height, to);
Width = LocaleHelper.ConvertMeasurement(this.MeasurementUnit, Width, to);
Length = LocaleHelper.ConvertMeasurement(this.MeasurementUnit, Length, to);
this.MeasurementUnit = to;
}
/// <summary>
/// Gets the total amount for unprocessed payments
/// </summary>
/// <returns>The total amount for unprocessed payments</returns>
public LSDecimal TotalUnprocessed()
{
LSDecimal total = 0;
foreach (Payment item in this)
{
if ((item.PaymentStatus != PaymentStatus.Captured) &&
(item.PaymentStatus != PaymentStatus.Completed) &&
(item.PaymentStatus != PaymentStatus.Refunded) &&
(item.PaymentStatus != PaymentStatus.RefundPending) &&
(item.PaymentStatus != PaymentStatus.Void) &&
(item.PaymentStatus != PaymentStatus.VoidPending)
)
{
if (item.PaymentStatus == PaymentStatus.Authorized)
{
//THE PAYMENT MAY HAVE PARTIAL CAPTURES ATTACHED
total += (item.Amount - item.Transactions.GetTotalCaptured());
}
else
{
total += item.Amount;
}
}
}
return(total);
}
/// <summary>
/// Processes a payment refund event
/// </summary>
/// <param name="payment">The payment that is refunded</param>
/// <param name="refundAmount">The amount refunded</param>
public static void PaymentRefunded(Payment payment, LSDecimal refundAmount)
{
Order order = payment.Order;
order.Notes.Add(new OrderNote(order.OrderId, order.UserId, LocaleHelper.LocalNow, string.Format(Properties.Resources.PaymentRefunded, refundAmount), NoteType.SystemPrivate));
order.Notes.Save();
}
/// <summary>
/// Converts all dimensions, weight and price of this package to whole numbers
/// </summary>
public void ConvertAllToWholeNumbers()
{
Weight = Math.Ceiling((Decimal)Weight);
RetailValue = Math.Ceiling((Decimal)RetailValue);
Length = Math.Ceiling((Decimal)Length);
Width = Math.Ceiling((Decimal)Width);
Height = Math.Ceiling((Decimal)Height);
}
/// <summary>
/// Rounds dimensions, weight and price of this package upto given decimals
/// </summary>
/// <param name="decimals">number of decimals in fractional part</param>
public void RoundAll(int decimals)
{
Weight = Math.Round((Decimal)Weight, decimals);
RetailValue = Math.Round((Decimal)RetailValue, decimals);
Length = Math.Round((Decimal)Length, decimals);
Width = Math.Round((Decimal)Width, decimals);
Height = Math.Round((Decimal)Height, decimals);
}
/*public override Transaction DoCancelRecurring(CancelRecurringRequest request)
* {
* Transaction errTrans;
* string profileId = request.ProviderReference;
* if (string.IsNullOrEmpty(profileId))
* {
* errTrans = Transaction.CreateErrorTransaction(PaymentGatewayId, request.TransactionType, request.Subscription.EffectiveRecurringAmount, "E", "The original profile id is null.", request.RemoteIP);
* return errTrans;
* }
*
* Transaction trans = CreateTransaction(null, request.TransactionType);
* trans.Amount = request.Subscription.EffectiveRecurringAmount;
*
* return trans;
* }*/
/*public override Transaction DoModifyRecurring(ModifyRecurringRequest request)
* {
* Transaction errTrans;
* string profileId = request.ProviderReference;
* if (string.IsNullOrEmpty(profileId))
* {
* errTrans = Transaction.CreateErrorTransaction(PaymentGatewayId, request.TransactionType, request.EffectiveRecurringAmount, "E", "The original profile id is null.", request.RemoteIP);
* return errTrans;
* }
*
* Transaction trans = CreateTransaction(null, request.TransactionType);
* trans.Amount = request.EffectiveRecurringAmount;
*
* return trans;
* }*/
/*public override FetchUpdateRecurringResponse DoFetchUpdateRecurring(FetchUpdateRecurringRequest request)
* {
* throw new NotImplementedException("Not yet implemented");
* }*/
private Transaction CreateTransaction(TransactionType transactionType, LSDecimal transactionAmount)
{
//CREATE THE TRANSACTION OBJECT
Transaction transaction = new Transaction();
transaction.PaymentGatewayId = this.PaymentGatewayId;
transaction.TransactionType = transactionType;
bool accept = true;
if (ExecutionMode == GatewayExecutionMode.AlwaysAccept)
{
accept = true;
}
else if (ExecutionMode == GatewayExecutionMode.AlwaysReject)
{
accept = false;
}
else if (ExecutionMode == GatewayExecutionMode.Random)
{
accept = RandomAccept();
}
if (accept)
{
//successful
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.ProviderTransactionId = Guid.NewGuid().ToString();
transaction.TransactionDate = DateTime.UtcNow;
//if (payment != null)
//{
// transaction.Amount = payment.Amount;
//}
transaction.Amount = transactionAmount;
transaction.ResponseCode = "0";
transaction.ResponseMessage = "Transaction Successful";
transaction.AuthorizationCode = "";
transaction.AVSResultCode = "S"; // NOT SUPPORTED
transaction.CVVResultCode = "X"; // NO RESPONSE
HttpContext context = HttpContext.Current;
if (context != null)
{
transaction.RemoteIP = context.Request.ServerVariables["REMOTE_ADDR"];
transaction.Referrer = context.Request.ServerVariables["HTTP_REFERER"];
}
}
else
{
//failed
transaction.TransactionStatus = TransactionStatus.Failed;
transaction.ResponseCode = "999";
transaction.ResponseMessage = "Transaction Failed.";
}
return(transaction);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="referrer">The referrer</param>
/// <param name="startDate">The start date</param>
/// <param name="endDate">The end date</param>
/// <param name="orderCount">The order count</param>
/// <param name="productSubtotal">The total of products sold</param>
/// <param name="orderTotal">Total of all orders</param>
public ReferrerSalesSummary(String referrer, DateTime startDate, DateTime endDate, int orderCount, LSDecimal productSubtotal, LSDecimal orderTotal)
{
_Referrer = referrer;
_StartDate = startDate;
_EndDate = endDate;
_OrderCount = orderCount;
_ProductSubtotal = productSubtotal;
_SalesTotal = orderTotal;
}
/// <summary>
/// Adds a new transaction to the gift certificate for updating its balance
/// </summary>
/// <param name="oldBalance">The old balance</param>
/// <param name="newBalance">The new balance</param>
public void AddBalanceUpdatedTransaction(LSDecimal oldBalance, LSDecimal newBalance)
{
GiftCertificateTransaction trans = new GiftCertificateTransaction();
trans.Amount = newBalance - oldBalance;
trans.Description = string.Format("Gift certificate balance updated manually from {0:lc} to {1:lc}.", oldBalance, newBalance);
trans.TransactionDate = LocaleHelper.LocalNow;
this.Transactions.Add(trans);
}
/// <summary>
/// Captures this payment
/// </summary>
/// <param name="amount">The amount to capture</param>
/// <param name="final">If <b>true</b> this capture is considered to be the final capture</param>
/// <param name="async">If <b>true</b> payment is captured asynchronously</param>
public virtual void Capture(LSDecimal amount, bool final, bool async)
{
System.Web.HttpContext context = System.Web.HttpContext.Current;
if (context == null)
{
throw new ArgumentException("You must specify remoteIP when HttpContext.Current is null.", "remoteIP");
}
this.Capture(amount, final, async, context.Request.UserHostAddress);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="affiliateId">Affiliate Id</param>
/// <param name="startDate">Start date for this summary data</param>
/// <param name="endDate">End date for this summary data</param>
/// <param name="orderCount">Total number of orders</param>
/// <param name="productSubtotal">Subtotal of products</param>
/// <param name="orderTotal">Total value of orders</param>
public AffiliateSalesSummary(int affiliateId, DateTime startDate, DateTime endDate, int orderCount, LSDecimal productSubtotal, LSDecimal orderTotal)
{
_AffiliateId = affiliateId;
_StartDate = startDate;
_EndDate = endDate;
_OrderCount = orderCount;
_ProductSubtotal = productSubtotal;
_OrderTotal = orderTotal;
}
public override LSDecimal GetTaxResult(Order ThisOrder, AnonymousAddress Address, LSDecimal ShippingRate)
{
CommerceBuilder.Orders.Basket basket = ThisOrder.AcBasket;
if (basket == null)
{
basket = AcHelper.GetAcBasket(ThisOrder.ShoppingCart, true);
if (basket != null)
{
basket.Package(false);
}
ThisOrder.AcBasket = basket;
}
if (basket != null)
{
Orders.BasketItem basketItem = null;
if (ShippingRate > 0)
{
//only temporarily add basket item for tax calculations
basketItem = new Orders.BasketItem();
basketItem.OrderItemType = Orders.OrderItemType.Shipping;
basketItem.Price = ShippingRate;
basketItem.Quantity = 1;
basketItem.Name = "Temp_GoogleCheckout";
//this basket item should be linked to the shipment
if (basket.Shipments.Count > 0)
{
basketItem.BasketShipmentId = basket.Shipments[0].BasketShipmentId;
}
basket.Items.Add(basketItem);
basketItem.BasketId = basket.BasketId;
basketItem.Save();
}
CommerceBuilder.Users.Address acAddress = AcHelper.GetAnonAcAddress(basket.User, Address);
UpdateBillingAddress(basket.User, acAddress);
foreach (Orders.BasketShipment shipment in basket.Shipments)
{
UpdateShipmentAddress(shipment, acAddress);
}
LSDecimal RetVal = Taxes.TaxCalculator.Calculate(basket);
//now that the tax rate is calculated, we can remove the additional basket item
if (basketItem != null)
{
basket.Items.Remove(basketItem);
basketItem.Delete();
}
return(RetVal);
}
else
{
return(0);
}
}
public ChargeOrderRequest(string MerchantID, string MerchantKey,
string Env, string OrderNo, string Currency, LSDecimal Amount)
{
_MerchantID = MerchantID;
_MerchantKey = MerchantKey;
_Environment = StringToEnvironment(Env);
_OrderNo = OrderNo;
_Currency = Currency;
_Amount = Amount;
}
/// <summary>
/// Ensures no package in the package list is below the minimum weight.
/// </summary>
/// <param name="minWeight">The minimum weight that a package should have</param>
public void EnsureMinimumWeight(LSDecimal minWeight)
{
foreach (Package item in this)
{
if (item.Weight < minWeight)
{
item.Weight = minWeight;
}
}
}
/// <summary>
/// Submits an authorization request
/// </summary>
/// <param name="authorizeRequest">The authorization request</param>
/// <returns>Transaction that represents the result of the authorization request</returns>
public override Transaction DoAuthorize(AuthorizeTransactionRequest authorizeRequest)
{
Transaction transaction = new Transaction();
transaction.PaymentGatewayId = this.PaymentGatewayId;
//always use authorize capture.
transaction.TransactionType = TransactionType.AuthorizeCapture;
string serialNumber = authorizeRequest.Payment.AccountData;
GiftCertificate gc = GiftCertificateDataSource.LoadForSerialNumber(serialNumber);
string errorMessage = string.Empty;
if (gc == null)
{
errorMessage = "No gift certificate found with given serial number.";
}
else if (gc.IsExpired())
{
errorMessage = "Gift certificate is expired.";
}
else if (gc.Balance < authorizeRequest.Amount)
{
errorMessage = "Gift certificate does not have enough balance to complete this transaction.";
}
else
{
LSDecimal newAmount = gc.Balance - authorizeRequest.Amount;
gc.Balance = newAmount;
GiftCertificateTransaction trans = new GiftCertificateTransaction();
trans.TransactionDate = LocaleHelper.LocalNow;
trans.Amount = authorizeRequest.Amount;
trans.OrderId = authorizeRequest.Payment.OrderId;
trans.Description = string.Format("An amount of {0:lc} used in purchase. Remaining balance is {1:lc}.", authorizeRequest.Amount, newAmount);
gc.Transactions.Add(trans);
gc.Save();
}
if (string.IsNullOrEmpty(errorMessage))
{
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.ResponseCode = "0";
transaction.ResponseMessage = "SUCCESS";
transaction.Amount = authorizeRequest.Amount;
}
else
{
transaction.TransactionStatus = TransactionStatus.Failed;
transaction.ResponseCode = "1";
transaction.ResponseMessage = errorMessage;
transaction.Amount = authorizeRequest.Amount;
}
return(transaction);
}
/// <summary>
/// Calculates and applies taxes for the given order
/// </summary>
/// <param name="basket">The order to calculate taxes on.</param>
/// <returns>The total amount of tax applied.</returns>
/// <remarks>Any pre-existing tax line items must be removed from the order before the calculation.</remarks>
public override LSDecimal Recalculate(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
// CREATE THE DOR GATEWAY INSTANCE
DorGateway gateway = new DorGateway(order, this.TaxName, this.UseDebugMode);
// BUILD A DICTIONARY OF TAXABLE TOTALS BY SHIPMENT
Dictionary <int, decimal> shipmentTotals = new Dictionary <int, decimal>();
// LOOP ITEMS IN BASKET TO CALCULATE TAX
OrderItemCollection newTaxItems = new OrderItemCollection();
foreach (OrderItem item in order.Items)
{
// SEE IF ITEM HAS A TAX CODE THAT APPLIES
if (item.TaxCodeId > 0 && this.TaxCodes.Contains(item.TaxCodeId))
{
if (shipmentTotals.ContainsKey(item.OrderShipmentId))
{
shipmentTotals[item.OrderShipmentId] += (decimal)item.ExtendedPrice;
}
else
{
shipmentTotals[item.OrderShipmentId] = (decimal)item.ExtendedPrice;
}
}
}
// LOOP TAXABLE SHIPMENT TOTALS
LSDecimal totalTax = 0;
foreach (int shipmentId in shipmentTotals.Keys)
{
// SEE IF THERE IS A TAXINFO INSTANCE FOR THIS ITEM
TaxInfo taxInfo = gateway.GetTaxInfo(shipmentId);
if (taxInfo != null)
{
// A TAXINFO STRUCTURE EXISTS, SO CREATE TAX ITEM AND ADD TO BASKET
OrderItem taxItem = TaxUtility.GenerateOrderItem(order.OrderId, shipmentId, shipmentTotals[shipmentId], taxInfo);
totalTax += taxItem.ExtendedPrice;
order.Items.Add(taxItem);
}
}
// SAVE ORDER
order.Items.Save();
// return total tax added to basekt
return(newTaxItems.TotalPrice());
}
private LSDecimal ParseTaxTransaction(CertiTAX.TaxTransaction taxTransaction, Basket basket, int shipmentId)
{
if (taxTransaction == null)
{
return(0);
}
LSDecimal totalTaxes = 0;
if (this.ReportBreakdown)
{
if (taxTransaction.CityTax > 0)
{
totalTaxes += taxTransaction.CityTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.CityTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.CityTax);
}
if (taxTransaction.CountyTax > 0)
{
totalTaxes += taxTransaction.CountyTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.CountyTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.CountyTax);
}
if (taxTransaction.LocalTax > 0)
{
totalTaxes += taxTransaction.LocalTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.LocalTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.LocalTax);
}
if (taxTransaction.StateTax > 0)
{
totalTaxes += taxTransaction.StateTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.StateTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.StateTax);
}
if (taxTransaction.NationalTax > 0)
{
totalTaxes += taxTransaction.NationalTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.NationalTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.NationalTax);
}
if (taxTransaction.OtherTax > 0)
{
totalTaxes += taxTransaction.OtherTax;
CreateTaxLineItem(basket, shipmentId, taxTransaction.OtherTaxAuthority, taxTransaction.CertiTAXTransactionId, taxTransaction.OtherTax);
}
}
else
{
totalTaxes += taxTransaction.CityTax;
totalTaxes += taxTransaction.CountyTax;
totalTaxes += taxTransaction.LocalTax;
totalTaxes += taxTransaction.StateTax;
totalTaxes += taxTransaction.NationalTax;
totalTaxes += taxTransaction.OtherTax;
CreateTaxLineItem(basket, shipmentId, "Tax", taxTransaction.CertiTAXTransactionId, totalTaxes);
}
return(totalTaxes);
}
/// <summary>
/// Converts an amount in the currency specified by this instance into the
/// base currency.
/// </summary>
/// <param name="value">The amount in this currency to convert</param>
/// <returns>The converted amount</returns>
public LSDecimal ConvertToBase(LSDecimal value)
{
Currency baseCurrency = Token.Instance.Store.BaseCurrency;
if (baseCurrency.CurrencyId == this.CurrencyId)
{
return(value);
}
LSDecimal convertedValue = Math.Round((decimal)(value / this.ExchangeRate), baseCurrency.DecimalDigits);
return(convertedValue);
}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}