public async Task<IHttpActionResult> Delete(int id, string email)
        {
            var order = await repository.RetrieveAsync(id);
            if (order == null)
            {
                return NotFound();
            }
            var payment = order.Payments.First();
            if (payment.PaymentType != PaymentType.PendingInvoice)
            {
                return NotFound();
            }

            //retrieve previous invoice
            APIContext apiContext = PaypalConfiguration.GetAPIContext();
            InvoiceDetails details = JsonConvert.DeserializeObject<InvoiceDetails>(payment.PaymentDetails);
            try
            {
                //check if old invoice is still valid
                var invoice = Invoice.Get(apiContext, details.id);

                //cancel invoice
                var cancelNotification = new CancelNotification
                {
                    subject = "Payment Canceled",
                    note = "The payment has been canceled.",
                    send_to_merchant = true,
                    send_to_payer = true
                };
                invoice.Cancel(apiContext, cancelNotification);
            }
            catch(Exception e)
            {
                //not valid, keep on trucking!
            }

            //create newinvoice
            Invoice newInvoice = CreateInvoice(email, order);

            newInvoice.id = order.OrderID.ToString();

            try
            {
                var createdInvoice = newInvoice.Create(apiContext);
                createdInvoice.Send(apiContext, true);

                var invoiceDetails = new
                {
                    id = createdInvoice.id,
                    email = email
                };

                payment.PaymentDetails = JsonConvert.SerializeObject(invoiceDetails);

                await repository.UpdateAsync(order, order.OrderID);
                return Ok(new { OrderID = order.OrderID });
            }
            catch (Exception ex)
            {
                await Logger.WriteLog(LogType.Error, ex.ToString());
                throw ex;
            }
        }
        public async Task<IHttpActionResult> Post(CashierOrderApiModel model)
        {
            if (model == null || model.Tickets.Length == 0)
            {
                return Ok();
            }

            //Create Order
            DexCMS.Tickets.Orders.Models.Order order = new DexCMS.Tickets.Orders.Models.Order
            {
                EnteredOn = cstTime,
                OrderStatus = OrderStatus.Pending,
                OrderTicketReferences = new List<OrderTicketReference>(),
                UserName = User.Identity.Name
            };

            foreach (var item in model.Tickets)
            {
                OrderTicketReference ticketRef = new OrderTicketReference
                {
                    TicketSeatID = item.TicketSeatID,
                    PendingPurchaseConfirmation = item.ConfirmationNumber,
                    EventAgeGroupID = item.AgeID,
                    TicketDiscountID = item.TicketDiscountID,
                    SecurityConfirmationNumber = item.DiscountConfirmationNumber,
                    TotalPrice = item.TotalPrice
                };

                if (item.Options != null && item.Options.Count > 0)
                {
                    ticketRef.TicketOptionChoices = new List<int>();
                    foreach (KeyValuePair<int, int> optionChoice in item.Options)
                    {
                        ticketRef.TicketOptionChoices.Add(optionChoice.Value);
                    }
                }

                order.OrderTicketReferences.Add(ticketRef);
            }

            //save
            await repository.AddAsync(order);


            //! CHANGING HERE
            switch (model.CashierOrderType)
            {
                case CashierOrderType.CashOrCheck:
                    return Ok(new { OrderID = order.OrderID });

                case CashierOrderType.Paypal:
                     Invoice invoice = CreateInvoice(model.InvoiceEmail, order);
                    invoice.id = order.OrderID.ToString();

                    try
                    {
                        var apiContext = PaypalConfiguration.GetAPIContext();
                        var createdInvoice = invoice.Create(apiContext);
                        createdInvoice.Send(apiContext, true);

                        var invoiceDetails = new
                        {
                            id = createdInvoice.id,
                            email = model.InvoiceEmail
                        };

                        order.Payments = new List<Orders.Models.Payment>
                        {
                            new Orders.Models.Payment
                            {
                                OrderID = order.OrderID,
                                PaymentDetails = JsonConvert.SerializeObject(invoiceDetails),
                                PaymentType = PaymentType.PendingInvoice
                            }
                        };
                        order.OrderStatus = OrderStatus.Pending;

                        await repository.UpdateAsync(order, order.OrderID);
                        return Ok(new { OrderID = order.OrderID });
                    }
                    catch (Exception ex)
                    {
                        await Logger.WriteLog(LogType.Error, ex.ToString());
                        throw ex;
                    }
  
                default:
                    return Ok();
            }          
        }