public Core.Finance.Domain.Order GetOrder(long orderId)
{
OrderEntity orderEntity;
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(myAdapter);
try
{
orderEntity = linqMetaData.Order.Single(o => o.OrderId == orderId);
}
catch (NotSupportedException)
{
throw new ObjectNotFoundInPersistenceException <Core.Finance.Domain.Order>(orderId);
}
}
List <OrderDetail> orderDetails = _orderDetailRepository.GetOrderDetailsForOrder(orderId);
IEnumerable <PaymentInstrument> paymentsApplied = _paymentInstrumentRepository.GetByOrderId
(orderId);
Core.Finance.Domain.Order order = _mapper.Map(orderEntity);
order.OrderDetails = orderDetails;
order.PaymentsApplied = paymentsApplied.ToList();
// TODO: This has to be moved to each payment instrument repository.
// HACK: This is done to fetch datarecorder metadata for the payments made for this order.
var payments = _paymentRepository.GetByOrderId(order.Id);
order.PaymentsApplied.ForEach(
pa => pa.DataRecorderMetaData = payments.Single(p => p.Id == pa.PaymentId).DataRecorderMetaData);
return(order);
}
public Core.Finance.Domain.Order RefundOrder(Core.Finance.Domain.Order order)
{
if (!_lineItems.Any())
{
throw new InvalidOperationException("The order must contain at least one line item.");
}
if (order == null)
{
throw new InvalidOperationException("The order can not be null.");
}
using (var transaction = new TransactionScope())
{
foreach (var lineItem in _lineItems)
{
OrderItem orderItem = _orderItemRepository.SaveOrderItem(lineItem.SecondValue.Id,
lineItem.SecondValue.OrderItemType);
lineItem.FirstValue.OrderItemId = orderItem.Id;
lineItem.FirstValue.OrderId = order.Id;
order.OrderDetails.Add(lineItem.FirstValue);
}
order = _orderRepository.SaveOrder(order);
transaction.Complete();
}
_lineItems.Clear();
return(order);
}
private Func <PaymentInstrument, bool> GetClosingCountPredicate(Core.Finance.Domain.Order currentOrder)
{
return(pa => pa.DataRecorderMetaData != null &&
pa.DataRecorderMetaData.DataRecorderCreator.Id == currentOrder.DataRecorderMetaData.DataRecorderCreator.Id &&
pa.DataRecorderMetaData.DateCreated <= currentOrder.DataRecorderMetaData.DateCreated.AddHours(1) &&
(pa is ECheckPayment || pa is ChargeCardPayment) && pa.Amount > 0);
}
private void CreatePaymentModeMetrics(EventMetricsViewData eventMetricsViewData,
Core.Finance.Domain.Order order, bool noShow)
{
var organizationRoleUserCreator =
_organizationRoleUserRepository.GetOrganizationRoleUser(order,
o =>
o.DataRecorderMetaData.DataRecorderCreator.Id);
// If the customer is noShow and Unpiad the count remain same.
if (noShow || order.DiscountedTotal != order.TotalAmountPaid)
{
return;
}
var roleId = GetParentRoleIdByRoleId(organizationRoleUserCreator.RoleId);
if (roleId == (int)Roles.CallCenterRep)
{
eventMetricsViewData.PhonePayments += order.DiscountedTotal;
eventMetricsViewData.PhonePaymentCount++;
}
else if (roleId == (int)Roles.Technician)
{
eventMetricsViewData.OnsitePaymentCount++;
eventMetricsViewData.OnsitePayments += order.DiscountedTotal;
}
else if (roleId == (int)Roles.Customer)
{
eventMetricsViewData.InternetPaymentCount++;
eventMetricsViewData.InternetPayments += order.DiscountedTotal;
}
}
public CallCenterRepStatisticsViewData GetClosedEventCustomerStatisticsForCallCenterRep(long callCenterCallCenterUserId,
DateTime startDate, DateTime endDate)
{
List <Core.Finance.Domain.Order> orders =
_orderRepository.GetAllOrdersCreatedByCallCenterRep(callCenterCallCenterUserId, startDate, endDate);
IUniqueItemRepository <EventCustomer> eventCustomerRepository = new EventCustomerRepository();
int totalCustomers, totalCancelled, totalNoShow, totalAttended;
totalCustomers = totalCancelled = totalNoShow = totalAttended = 0;
decimal totalAmount = 0m;
foreach (var order in orders)
{
Core.Finance.Domain.Order currentOrder = order;
//It will ignore 100% discounted orders.
if (GetTotalPackagePriceDiscountPredicate(order))
{
continue;
}
if (currentOrder != null && !GetReSchedulePredicate(currentOrder) && order.PaymentsApplied.Any(GetClosingCountPredicate(currentOrder)))
{
totalCustomers++;
// It will eliminate cancelled records. But add to the the cancelled records.
if (!order.OrderDetails.Any(od => (od.DetailType == OrderItemType.EventPackageItem || od.DetailType == OrderItemType.EventTestItem) && od.IsCompleted))
{
totalCancelled++;
continue;
}
var activeOrderDetail = _orderController.GetActiveOrderDetail(order);
if (activeOrderDetail != null && activeOrderDetail.EventCustomerOrderDetail != null)
{
var eventCustomer =
eventCustomerRepository.GetById(
activeOrderDetail.EventCustomerOrderDetail.EventCustomerId);
if (eventCustomer.AppointmentId.HasValue && eventCustomer.NoShow)
{
totalNoShow++;
continue;
}
if (eventCustomer.TestConducted)
{
totalAttended++;
}
}
totalAmount += order.DiscountedTotal;
}
}
return(new CallCenterRepStatisticsViewData(totalCustomers, totalCancelled, totalNoShow, totalAttended,
totalAmount));
}
// This method determines if 100% coupon is applied.
private bool GetTotalPackagePriceDiscountPredicate(Core.Finance.Domain.Order currentOrder)
{
var activeOrderDetail = _orderController.GetActiveOrderDetail(currentOrder);
if (activeOrderDetail != null && activeOrderDetail.SourceCodeOrderDetail != null && ((activeOrderDetail.Price * activeOrderDetail.Quantity) == activeOrderDetail.SourceCodeOrderDetail.Amount))
{
return(true);
}
return(false);
}
private void CreateRevenueMetrics(EventMetricsViewData eventMetricsViewData, Core.Finance.Domain.Order order, bool noShow)
{
if (order.DiscountedTotal > order.TotalAmountPaid)
{
eventMetricsViewData.UnPaidCount++;
eventMetricsViewData.UnPaidRevenue += order.DiscountedTotal - order.TotalAmountPaid;
if (!noShow)
{
eventMetricsViewData.UnPaidExcluedeNoShowCount++;
eventMetricsViewData.UnPaidExcluedeNoShowRevenue += order.DiscountedTotal - order.TotalAmountPaid;
}
}
//if (order.PaymentsApplied.Any(pa => pa.PaymentType == PaymentType.CreditCard))
//{
// var chargeCardPayment = order.PaymentsApplied.Where(pa => pa.PaymentType == PaymentType.CreditCard);
// //eventMetricsViewData.ChargeCardCount += chargeCardPayment.Count();
// eventMetricsViewData.ChargeCardCount++;
// eventMetricsViewData.ChargeCardRevenue += chargeCardPayment.Sum(ccp => ccp.Amount);
//}
//if (order.PaymentsApplied.Any(pa => pa.PaymentType == PaymentType.Check))
//{
// var checkPayment = order.PaymentsApplied.Where(pa => pa.PaymentType == PaymentType.Check);
// //eventMetricsViewData.CheckCount += checkPayment.Count();
// eventMetricsViewData.CheckCount++;
// eventMetricsViewData.CheckRevenue += checkPayment.Sum(ccp => ccp.Amount);
//}
//if (order.PaymentsApplied.Any(pa => pa.PaymentType == PaymentType.ElectronicCheck))
//{
// var eCheckPayment = order.PaymentsApplied.Where(pa => pa.PaymentType == PaymentType.ElectronicCheck);
// //eventMetricsViewData.ECheckCount += eCheckPayment.Count();
// eventMetricsViewData.ECheckCount++;
// eventMetricsViewData.ECheckRevenue += eCheckPayment.Sum(ccp => ccp.Amount);
//}
//if (order.PaymentsApplied.Any(pa => pa.PaymentType == PaymentType.Cash))
//{
// var cashPayment = order.PaymentsApplied.Where(pa => pa.PaymentType == PaymentType.Cash);
// //eventMetricsViewData.CashCount += cashPayment.Count();
// eventMetricsViewData.CashCount++;
// eventMetricsViewData.CashRevenue += cashPayment.Sum(ccp => ccp.Amount);
//}
//if (order.PaymentsApplied.Any(pa => pa.PaymentType == PaymentType.GiftCertificate))
//{
// var giftCertificatePayment =
// order.PaymentsApplied.Where(pa => pa.PaymentType == PaymentType.GiftCertificate);
// //eventMetricsViewData.GiftCertificateCount += giftCertificatePayment.Count();
// eventMetricsViewData.GiftCertificateCount++;
// eventMetricsViewData.GiftCertificateRevenue += giftCertificatePayment.Sum(ccp => ccp.Amount);
//}
//eventMetricsViewData.TotalRevenue += order.DiscountedTotal;
}
private OrderDetail GetCurrentOrder(long customerId, long eventId)
{
IOrderRepository orderRepository = new OrderRepository();
try
{
_order = orderRepository.GetOrder(customerId, eventId);
IOrderController orderController = new OrderController();
return(orderController.GetActiveOrderDetail(_order));
}
catch
{
return(null);
}
}
private void SetCreditCardOnFileDetails(Core.Finance.Domain.Order order)
{
var creditCardPaymentInstrument =
order.PaymentsApplied.OrderBy(pa => pa.DataRecorderMetaData.DateCreated).LastOrDefault(pa => pa.PaymentType == PaymentType.CreditCard) as
ChargeCardPayment;
if (creditCardPaymentInstrument == null)
{
return;
}
string reasonForFailure = "";
if (!IoC.Resolve <IChargeCardService>().IsCardValidforRefund(creditCardPaymentInstrument, 0, out reasonForFailure))
{
Page.ClientScript.RegisterHiddenField(IsValidCardHiddenFieldName, Boolean.FalseString);
}
else
{
Page.ClientScript.RegisterHiddenField(IsValidCardHiddenFieldName, Boolean.TrueString);
}
IChargeCardRepository chargeCardRepository = new ChargeCardRepository();
var existingChargeCard = chargeCardRepository.GetById(creditCardPaymentInstrument.ChargeCardId);
spcardholder.InnerText = existingChargeCard.NameOnCard;
string cardnumber = existingChargeCard.Number;
if (cardnumber.Length > 0)
{
string dispcardnumber = string.Empty;
for (int jcount = 0; jcount < cardnumber.Length - 4; jcount++)
{
dispcardnumber = dispcardnumber + "X";
}
dispcardnumber += cardnumber.Substring(cardnumber.Length - 4, 4);
spccnumber.InnerText = dispcardnumber;
spcctype.InnerText =
Enum.Parse(typeof(ChargeCardType), existingChargeCard.TypeId.ToString()).ToString();
spexpdate.InnerText = existingChargeCard.ExpirationDate.ToString("MM/yyyy");
ddlpaymentmode.Items.Clear();
ddlpaymentmode.Items.Insert(ddlpaymentmode.Items.Count, new ListItem(PaymentType.CreditCardOnFile_Text, PaymentType.CreditCardOnFile_Value.ToString()));
}
}
private void SaveProductShippingDetail(Core.Finance.Domain.Order order)
{
if (ProductId.HasValue && ProductId.Value > 0)
{
var shippingOptionRepository = IoC.Resolve <IShippingOptionRepository>();
var shippingOption = shippingOptionRepository.GetShippingOptionByProductId(ProductId.Value);
if (shippingOption == null || ShippingDetail == null)
{
return;
}
IOrderController orderController = new OrderController();
OrderDetail orderDetail = orderController.GetActiveOrderDetail(order);
if (shippingOption.Id == ShippingDetail.ShippingOption.Id)
{
return;
}
var productShippingDetail = ShippingDetail;
productShippingDetail.Id = 0;
productShippingDetail.ShippingAddress.Id = 0;
productShippingDetail.ShippingOption.Id = shippingOption.Id;
productShippingDetail.ActualPrice = shippingOption.Price;
if (orderDetail != null)
{
IShippingController shippingController = new ShippingController();
productShippingDetail = shippingController.OrderShipping(productShippingDetail);
IRepository <ShippingDetailOrderDetail> shippingDetailOrderDetailRepository =
new ShippingDetailOrderDetailRepository();
var shippingDetailOrderDetail = new ShippingDetailOrderDetail
{
Amount = productShippingDetail.ActualPrice,
IsActive = true,
OrderDetailId = orderDetail.Id,
ShippingDetailId = productShippingDetail.Id
};
shippingDetailOrderDetailRepository.Save(shippingDetailOrderDetail);
}
}
}
public Core.Finance.Domain.Order PlaceOrder(Core.Finance.Domain.Order order)
{
var newOrder = _orderFactory.CreateDuplicateOrder(order);
if (!_lineItems.Any())
{
throw new InvalidOperationException("The order must contain at least one line item.");
}
if (order == null)
{
throw new InvalidOperationException("The order can not be null.");
}
using (var transaction = new TransactionScope())
{
foreach (var lineItem in _lineItems)
{
OrderItem orderItem = _orderItemRepository.SaveOrderItem(lineItem.SecondValue.Id, lineItem.SecondValue.OrderItemType);
lineItem.FirstValue.OrderItemId = orderItem.Id;
lineItem.FirstValue.OrderId = order.Id;
newOrder.OrderDetails.Add(lineItem.FirstValue);
}
// Get the new sourceCode applied...
var orderDetailWithSourceCode = newOrder.OrderDetails.SingleOrDefault(od => od.SourceCodeOrderDetail != null);
var sourceCodeOrderDetail = orderDetailWithSourceCode != null
? orderDetailWithSourceCode.SourceCodeOrderDetail
: null;
if (orderDetailWithSourceCode != null)
{
orderDetailWithSourceCode.SourceCodeOrderDetail = null;
}
newOrder = _orderSynchronizationService.SynchronizeOrder(order, newOrder, sourceCodeOrderDetail);
newOrder = _orderRepository.SaveOrder(newOrder);
transaction.Complete();
}
_lineItems.Clear();
return(newOrder);
}
private void SetCreditCardOnFileDetails(Core.Finance.Domain.Order order)
{
var creditCardPaymentInstrument =
order.PaymentsApplied.LastOrDefault(pa => pa.PaymentType == PaymentType.CreditCard) as
ChargeCardPayment;
if (creditCardPaymentInstrument != null)
{
IChargeCardRepository chargeCardRepository = new ChargeCardRepository();
var existingChargeCard = chargeCardRepository.GetById(creditCardPaymentInstrument.ChargeCardId);
CreditCardHolderName.Text = HttpUtility.HtmlEncode(existingChargeCard.NameOnCard);
string cardNumber = existingChargeCard.Number;
if (cardNumber.Length > 0)
{
string displayCardNumber = string.Empty;
for (int jcount = 0; jcount < cardNumber.Length - 4; jcount++)
{
displayCardNumber += "X";
}
displayCardNumber += cardNumber.Substring(cardNumber.Length - 4, 4);
CreditCardNumberLabel.Text = HttpUtility.HtmlEncode(displayCardNumber);
CreditCardTypeLabel.Text =
Enum.Parse(typeof(ChargeCardType), existingChargeCard.TypeId.ToString()).ToString();
ExpirationDateLabel.Text = existingChargeCard.ExpirationDate.ToString("MM/yyyy");
ListItem listItem = PaymentModeCombo.Items.FindByText("Credit Card");
if (listItem != null)
{
PaymentModeCombo.Items.Insert(PaymentModeCombo.Items.Count, new ListItem("Credit Card on File", CC_ON_FILE_VALUE));
}
}
else
{
Page.ClientScript.RegisterStartupScript(typeof(string), "JSCODE",
"alert('The credit card number supplied is invalid.So you have to enter new credit card information if you wish to refund via credit card');",
true);
}
}
}
public Core.Finance.Domain.Order SaveOrder(Core.Finance.Domain.Order orderToSave)
{
OrderEntity orderEntity = _mapper.Map(orderToSave);
// TODO: Better method of saving Order + Details?
using (var transactionScope = new TransactionScope())
{
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
if (!myAdapter.SaveEntity(orderEntity, true))
{
throw new PersistenceFailureException();
}
}
orderToSave.OrderDetails.ForEach(orderDetail => orderDetail.OrderId = orderEntity.OrderId);
orderToSave.OrderDetails = _orderDetailRepository.SaveOrderDetails
(orderToSave.OrderDetails);
transactionScope.Complete();
}
Core.Finance.Domain.Order order = _mapper.Map(orderEntity);
order.OrderDetails = orderToSave.OrderDetails;
return(order);
}
private void SetCreditCardOnFileDetails(Core.Finance.Domain.Order order)
{
var creditCardPaymentInstrument =
order.PaymentsApplied.OrderBy(pa => pa.DataRecorderMetaData.DateCreated).LastOrDefault(pa => pa.PaymentType == PaymentType.CreditCard) as
ChargeCardPayment;
if (creditCardPaymentInstrument == null)
{
return;
}
IChargeCardRepository chargeCardRepository = new ChargeCardRepository();
var existingChargeCard = chargeCardRepository.GetById(creditCardPaymentInstrument.ChargeCardId);
spcardholder.InnerText = existingChargeCard.NameOnCard;
string cardnumber = existingChargeCard.Number;
if (cardnumber.Length > 0)
{
string dispcardnumber = "";
for (int jcount = 0; jcount < cardnumber.Length - 4; jcount++)
{
dispcardnumber = dispcardnumber + "X";
}
dispcardnumber += cardnumber.Substring(cardnumber.Length - 4, 4);
spccnumber.InnerText = dispcardnumber;
spcctype.InnerHtml =
Enum.Parse(typeof(ChargeCardType), existingChargeCard.TypeId.ToString()).ToString();
spexpdate.InnerHtml = existingChargeCard.ExpirationDate.ToString("MM/yyyy");
//hfCardTypeId.Value = ((int)existingChargeCard.TypeId).ToString();
ddlpaymentmode.Items.Insert(ddlpaymentmode.Items.Count, new ListItem(PaymentType.CreditCardOnFile_Text, PaymentType.CreditCardOnFile_Value.ToString()));
}
}
public Core.Finance.Domain.Order UpdateOrder(Core.Finance.Domain.Order order, SourceCode sourceCode, long dataRecorderCreatorId)
{
if (order == null)
{
throw new InvalidOperationException("The order can not be null.");
}
var existingActiveOrderDetail = GetActiveOrderDetail(order);
if (existingActiveOrderDetail == null)
{
throw new InvalidOperationException("The order must contain at least one active line item.");
}
if (existingActiveOrderDetail.EventCustomerOrderDetail == null)
{
throw new InvalidOperationException("The order must contain at least one active line item.");
}
existingActiveOrderDetail.SourceCodeOrderDetail = new SourceCodeOrderDetail
{
Amount = sourceCode.CouponValue,
OrderDetailId = existingActiveOrderDetail.Id,
IsActive = true,
OrganizationRoleUserCreatorId =
dataRecorderCreatorId,
SourceCodeId = sourceCode.Id
};
using (var transaction = new TransactionScope())
{
order = _orderRepository.SaveOrder(order);
transaction.Complete();
}
return(order);
}
public void SetOrderPackageTest(Core.Finance.Domain.Order order, EventCustomerPackageTestDetailViewData eventCustomerPackageTestDetailViewData)
{
IOrderController orderController = new OrderController();
var orderDetail = orderController.GetActiveOrderDetail(order);
var shippingPrice = Math.Round(orderDetail.ShippingDetailOrderDetails.Sum(sdod => sdod.Amount), 2);
if (eventCustomerPackageTestDetailViewData.Package != null)
{
lblPackagename.Text = eventCustomerPackageTestDetailViewData.Package.Name;
string packageTest = string.Empty;
foreach (var test in eventCustomerPackageTestDetailViewData.Package.Tests)
{
packageTest += "<li style=\"margin: 0px 10px; padding: 0px 0px; list-style: disc;\">" + test.Name + "</li>";
}
_lblTestNames.InnerHtml = packageTest;
}
else
{
_lblPackageRow.Visible = false;
AdditionalTest.InnerHtml = "Test(s):";
}
var additionalTest = string.Empty;
foreach (var test in eventCustomerPackageTestDetailViewData.Tests)
{
additionalTest += "<li style=\"margin: 0px 10px; padding: 0px 0px; list-style: disc;\">" + test.Name + "</li>";
}
_lblAdditionalTestNames.InnerHtml = additionalTest;
if (eventCustomerPackageTestDetailViewData.Tests.Count < 1)
{
_lblAdditionalTestRow.Visible = false;
}
if (eventCustomerPackageTestDetailViewData.ElectronicProduct != null)
{
//_lblProductNameRow.Visible = true;
//lblProductName.Text = eventCustomerPackageTestDetailViewData.ElectronicProduct.Name;
_lblProductPriceRow.Visible = true;
lblProductPrice.Text = eventCustomerPackageTestDetailViewData.ElectronicProduct.Price.ToString("C2");
}
else
{
//_lblProductNameRow.Visible = false;
_lblProductPriceRow.Visible = false;
}
string strPaymentStatus = "Not Paid";
if (order.TotalAmountPaid > 0 && order.TotalAmountPaid < order.DiscountedTotal)
{
strPaymentStatus = "Partially Paid";
}
else if (order.TotalAmountPaid >= order.DiscountedTotal)
{
strPaymentStatus = "Paid";
}
//strPaymentStatus = (order.TotalAmountPaid - order.DiscountedTotal) >= 0 ? "Paid" : "Not Paid";
lblPrice.Text = (order.OrderValue - order.OrderDiscount).ToString("C2");
lblShippingPrice.Text = orderDetail.ShippingDetailOrderDetails.Count > 0 ? shippingPrice.ToString("C2") : "N/A";
lblTotalPrice.Text = order.DiscountedTotal.ToString("C2");
lblPaymentStatus.Text = strPaymentStatus;
}
private void SetPaymentDetails(Core.Finance.Domain.Order order)
{
TotalAmountPayable = order.DiscountedTotal - order.TotalAmountPaid;
hfcurrentpayable.Value = (order.DiscountedTotal - order.TotalAmountPaid).ToString("0.00");
if (order.PaymentsApplied != null && !order.PaymentsApplied.IsEmpty())
{
//TODO:Currently it is removed as we don't have CC detail
SetCreditCardOnFileDetails(order);
bool unpaid = true;
string paidstring = string.Empty;
decimal paidamount = 0.00m;
foreach (var paymentApplied in order.PaymentsApplied)
{
if (paidstring.Trim().Length < 1)
{
paidstring = "Paid Amount:";
}
if (paymentApplied.Amount > 0)
{
paidamount += paymentApplied.Amount;
paidstring += " $" + paymentApplied.Amount.ToString("0.00") + " (" + paymentApplied.PaymentType + "),";
unpaid = false;
}
else if (paymentApplied.Amount < 0)
{
paidamount += paymentApplied.Amount;
paidstring += " Refund Amount: $" + (-1 * paymentApplied.Amount).ToString("0.00") + " (" + paymentApplied.PaymentType + "),";
unpaid = false;
}
}
if (TotalAmountPayable < 0)
{
paidstring += " | Unpaid Amount: $" + (TotalAmountPayable.Value * -1).ToString("0.00") + " <i>(To Refund) </i>";
}
else
{
paidstring += " | Unpaid Amount: $" + TotalAmountPayable.Value.ToString("0.00");
}
if (paidstring.Substring(paidstring.Length - 1, 1) == ",")
{
paidstring = paidstring.Substring(0, paidstring.Length - 1);
}
hfpaidamount.Value = paidamount.ToString("N2");
if (unpaid)
{
sppaymentdetails.InnerText = "Unpaid Amount: $" + TotalAmountPayable.Value.ToString("0.00");
}
else
{
sppaymentdetails.InnerHtml = paidstring;
}
}
else
{
sppaymentdetails.InnerHtml = "Unpaid Amount: $" + TotalAmountPayable.Value.ToString("0.00");
}
if (Customer != null)
{
var functionToCall = "javascript:return ShowOrderDetailPopUp(" +
HttpUtility.HtmlEncode(order.Id) + "," + HttpUtility.HtmlEncode(order.DiscountedTotal) + "," + HttpUtility.HtmlEncode(order.TotalAmountPaid) + "," +
HttpUtility.HtmlEncode(order.DiscountedTotal - order.TotalAmountPaid) + ",'" + HttpUtility.HtmlEncode(Customer.Name) + "'," +
HttpUtility.HtmlEncode(Customer.CustomerId) + ");";
_paymentLinkAnchor.Attributes.Add("onClick", functionToCall);
_paymentLinkAnchor.HRef = "javascript:void(0);";
}
}
public OrderDetail GetActiveOrderDetail(Core.Finance.Domain.Order order)
{
return(GetActiveOrderDetail(order.OrderDetails));
}
// This method eliminates records which have been rescheduled but not paid after rescheduling.
private bool GetReSchedulePredicate(Core.Finance.Domain.Order currentOrder)
{
return(currentOrder.DiscountedTotal > 0 && currentOrder.TotalAmountPaid == 0 &&
!GetTotalPackagePriceDiscountPredicate(currentOrder));
}
private void CreateChangeOrderMetrics(EventMetricsViewData eventMetricsViewData,
Core.Finance.Domain.Order order, OrganizationRoleUser organizationRoleUser)
{
// It means the order has been changed, so either downgrade or upgrade will occur for such cases only.
if (order.DiscountedTotal == order.TotalAmountPaid && order.OrderDetails.Count > 1)
{
order.OrderDetails.ForEach(od =>
{
od.DataRecorderMetaData.DateCreated =
od.DataRecorderMetaData.DateCreated.GetDateWithDifferentTime(
od.DataRecorderMetaData.DateCreated.Hour,
od.DataRecorderMetaData.DateCreated.Minute,
od.DataRecorderMetaData.DateCreated.Second);
if (od.Price < 0)
{
od.Price = 0;
}
});
Func <OrderDetail, decimal> amountOfDiscount = od => od.SourceCodeOrderDetail == null ? 0 : od.SourceCodeOrderDetail.Amount;
var dateCreatedGroups = order.OrderDetails.GroupBy(od => od.DataRecorderMetaData.DateCreated).Select(
g =>
new
{
g.Key,
TotalValue = g.Sum(od => (od.Price * od.Quantity) - (amountOfDiscount(od))),
AvailedValue = g.Where(od => od.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess
//EventPackageItemStatus.Availed || od.OrderItemStatus == EventTestItemStatus.Availed
).Sum(
od => ((od.Price * od.Quantity) - amountOfDiscount(od))),
CreatorId = g.Select(od => od.DataRecorderMetaData.DataRecorderCreator.Id).ToList()
}).ToList();
var availedPriceToBeAddedToNextGroup = 0m;
for (int counter = 0; counter < (dateCreatedGroups.Count - 1); counter++)
{
var changedOrderDetailOrganizationRoleUser =
_organizationRoleUserRepository.GetOrganizationRoleUser(
dateCreatedGroups[counter + 1].CreatorId.LastOrDefault());
var originalOrderDetailSum = dateCreatedGroups[counter].TotalValue +
availedPriceToBeAddedToNextGroup;
availedPriceToBeAddedToNextGroup += dateCreatedGroups[counter].AvailedValue;
var changedOrderDetailSum = dateCreatedGroups[counter + 1].TotalValue +
availedPriceToBeAddedToNextGroup;
if (changedOrderDetailSum == 0)
{
continue;
}
var roleId = GetParentRoleIdByRoleId(organizationRoleUser.RoleId);
if (roleId == (int)Roles.Technician)
{
if (GetParentRoleIdByRoleId(changedOrderDetailOrganizationRoleUser.RoleId) == (int)Roles.Technician)
{
if (originalOrderDetailSum > changedOrderDetailSum)
{
eventMetricsViewData.DownGradePaymentCount++;
eventMetricsViewData.DownGradePayments += originalOrderDetailSum - changedOrderDetailSum;
}
if (originalOrderDetailSum < changedOrderDetailSum)
{
eventMetricsViewData.UpGradePaymentCount++;
eventMetricsViewData.UpGradePayments += changedOrderDetailSum - originalOrderDetailSum;
}
}
}
else
{
if (originalOrderDetailSum > changedOrderDetailSum)
{
eventMetricsViewData.DownGradePaymentCount++;
eventMetricsViewData.DownGradePayments += originalOrderDetailSum - changedOrderDetailSum;
}
if (originalOrderDetailSum < changedOrderDetailSum)
{
eventMetricsViewData.UpGradePaymentCount++;
eventMetricsViewData.UpGradePayments += changedOrderDetailSum - originalOrderDetailSum;
}
}
}
}
}
private bool PaymentViaSourceCode()
{
var organizationRoleUser = GetOrganizationRoleUser();
var orderables = new List <IOrderable>();
var packageTestIds = new List <long>();
if (PackageId > 0)
{
var packageRepository = IoC.Resolve <IEventPackageRepository>();
var package = packageRepository.GetByEventAndPackageIds(EventId.Value, PackageId);
if (package != null)
{
packageTestIds = package.Tests.Select(t => t.Test.Id).ToList();
}
orderables.Add(package);
}
var independentTestIds = !packageTestIds.IsNullOrEmpty() ? TestIds.Where(t => !packageTestIds.Contains(t)).Select(t => t).ToList() : TestIds;
if (!independentTestIds.IsNullOrEmpty())
{
var eventTestRepository = IoC.Resolve <IEventTestRepository>();
orderables.AddRange(eventTestRepository.GetByEventAndTestIds(EventId.Value, independentTestIds));
}
if (ProductId.HasValue && ProductId.Value > 0)
{
IUniqueItemRepository <ElectronicProduct> itemRepository = new ElectronicProductRepository();
orderables.Add(itemRepository.GetById(ProductId.Value));
}
if (orderables.IsNullOrEmpty())
{
return(false);
}
Core.Finance.Domain.Order order = null;
EventCustomer eventCustomer;
try
{
order = GetOrder();
if (order == null)
{
eventCustomer = SaveEventCustomer(organizationRoleUser);
}
else
{
eventCustomer = UpdateEventCustomer(organizationRoleUser);
}
}
catch
{
eventCustomer = SaveEventCustomer(organizationRoleUser);
}
SourceCode sourceCode;
if (SourceCodeId > 0)
{
sourceCode = new SourceCode
{
Id = SourceCodeId,
CouponCode = SourceCode,
CouponValue = SourceCodeAmount
}
}
;
else
{
sourceCode = null;
}
if (ShippingDetail != null)
{
IShippingController shippingController = new ShippingController();
ShippingDetail = shippingController.OrderShipping(ShippingDetail);
}
IOrderController orderController = new OrderController();
bool indentedLineItemsAdded = false;
// TODO: applying hook to the system all the indented line items will be attached to the first order item.
foreach (var orderable in orderables)
{
if (!indentedLineItemsAdded)
{
orderController.AddItem(orderable, 1, organizationRoleUser.Id, organizationRoleUser.Id,
sourceCode,
eventCustomer, ShippingDetail, OrderStatusState.FinalSuccess);
indentedLineItemsAdded = true;
}
else
{
orderController.AddItem(orderable, 1, organizationRoleUser.Id, organizationRoleUser.Id,
OrderStatusState.FinalSuccess);
}
}
if (order == null)
{
order = orderController.PlaceOrder(OrderType.Retail, organizationRoleUser.Id);
}
else
{
order = orderController.ActivateOrder(order);
}
SaveProductShippingDetail(order);
return(true);
}
