public ActionResult tryCheckout(CheckoutInfo info)
{
ActionResult res = null;
PurchaseData purchase = PaymentController.getPurchaseById(info.purchaseId);
try
{
var charge = performCharge(info, purchase);
int updatedUserCredits = updateUserCredits(info, purchase, charge);
dynamic contentRes = new
{
charge,
updatedUserCredits
};
res = new ContentResult {
Content = JsonConvert.SerializeObject(contentRes),
ContentType = "application/json"
};
} catch (Exception e)
{
res = new ContentResult {
Content = JsonConvert.SerializeObject(e),
ContentType = "application/json",
StatusCode = 500
};
}
return(res);
}
public async Task <IActionResult> OnPost()
{
ProductIndex = _productVMService.GetProductsVM(HttpContext, null);
int?cartId = HttpContext.Session.GetInt32("cartId");
if (cartId != null)
{
productsInCart = (from p in ProductIndex.Products
join cp in _db.CartProducts on p.Id equals cp.ProductId
where cp.CartId == cartId
select p).ToList();
}
checkoutInfo = new CheckoutInfo(HttpContext.Session.GetInt32("cartId"), FirstName, LastName, Address, Apartment, City,
Country, Province, PostalCode, Phone, CardNumber, CardHolderName, ExpirationDate);
if (!ModelState.IsValid)
{
return(Page());
}
else
{
await _db.CheckoutInfos.AddAsync(checkoutInfo);
ShoppingCart cart = await _db.Carts.Where(c => c.Id == cartId).FirstOrDefaultAsync();
cart.setStatus(1);
await _db.SaveChangesAsync();
HttpContext.Session.Remove("cartId");
return(RedirectToPage("Confirmation"));
}
}
public IActionResult Payment(CheckoutInfo checkoutInfo)
{
var order = _context.Order
.Include(o => o.Basket)
.FirstOrDefault(x => x.OrderId == checkoutInfo.OrderId);
//Add shipping to total
var total = 0;
var service = new BasketService(_context);
total = service.GetTotal(HttpContext.Session);
var shipping = 0;
if (total < 500)
{
shipping = 49;
}
total += shipping;
order.Total = total;
order.Shipping = shipping;
_context.SaveChanges();
return(View(checkoutInfo));
}
public CheckoutInfo CheckoutInfo(ObjectIdentity objIdentity)
{
ObjectIdentitySet objIdSet = new ObjectIdentitySet();
objIdSet.Identities.Add(objIdentity);
List <CheckoutInfo> objList;
OperationOptions operationOptions = null;
versionControlService.Checkout(objIdSet, operationOptions);
objList = versionControlService.GetCheckoutInfo(objIdSet);
CheckoutInfo checkoutInfo = objList[0];
if (checkoutInfo.IsCheckedOut)
{
Console.WriteLine("Object "
+ checkoutInfo.Identity
+ " is checked out.");
Console.WriteLine("Lock owner is " + checkoutInfo.UserName);
}
else
{
Console.WriteLine("Object "
+ checkoutInfo.Identity
+ " is not checked out.");
}
versionControlService.CancelCheckout(objIdSet);
return(checkoutInfo);
}
private async Task UpdateStorage(Guid correlationId, int sagaStatus, CheckoutInfo checkoutInfo)
{
var updateSagaInfo = await _repository.GetByIdAsync(correlationId);
updateSagaInfo.Data = checkoutInfo.ToString <CheckoutInfo>();
updateSagaInfo.SagaStatus = sagaStatus;
await _repository.UpdateAsync(updateSagaInfo);
}
public ActionResult Checkout(CheckoutInfo checkInfo)
{
if (ModelState.IsValid)
{
cartRepository.CheckoutUser(cartRepository.UserInfo.First(p => p.LoginInformation.Username == HttpContext.User.Identity.Name).UserID);
return(RedirectToAction("HomeScreen", "Home"));
}
return(View(checkInfo));
}
protected override void Given()
{
base.Given();
SourceRepoDriver.GetLatestRevision().Returns(new RevisionInfo { Revision = "2344" });
SourceRepoDriver.GetSourceRevision(Arg.Any<string>(), Arg.Any<string>()).Returns(new CheckoutInfo(){Comment = "comment"});
WorkingAreaGovernor.AllocateWorkingArea().Returns("dugh");
Worker = new Worker(Pipeline, WorkingAreaGovernor);
Worker.OnProjectCheckedOut += info => checkoutInfo = info;
}
public ActionResult CreateNewCustomerPolicy()
{
int cusId = (int)Session["id"];
CustomerinfoDAORequest customerRequest = new CustomerinfoDAORequest();
Customer_Info customerInfo = customerRequest.searchCustomerById(cusId);
int policyID = int.Parse(Request.Params["idPolicyHidden"]);
PolicyDAORequest policyRequest = new PolicyDAORequest();
Policy policyInfo = policyRequest.searchPolicyById(policyID);
int modelId = int.Parse(Request.Params["cbVehicleModel"]);
ModelDAORequest dao = new ModelDAORequest();
Model model1 = dao.searchModelByModel(modelId);
ModelViewModel model = dao.GetModelById(modelId);
int vehicleCondition = int.Parse(Request.Params["condition"]);
Vehicle_Info newVehicle = new Vehicle_Info()
{
brand_id = int.Parse(Request.Form["cbVehicleBrand"]),
model_id = int.Parse(Request.Form["cbVehicleModel"]),
address = Request.Form["address"].ToString(),
owner_name = Request.Form["ownerName"].ToString(),
version = Request.Params["version"],
frame_number = Request.Params["frameNumber"],
engine_number = Request.Params["engineNumber"],
vehicle_number = Request.Params["vehicleNumber"],
vehicle_condition = vehicleCondition,
rate_by_condition = (vehicleCondition * model.rate) / 100,
Model = model1
};
Customer_Policy newCustomerPolicy = new Customer_Policy()
{
customer_id = cusId,
policy_id = policyID,
Vehicle_Info = newVehicle,
vehicle_id = newVehicle.id,
policy_start_date = DateTime.Parse(Request.Params["startDate"]),
policy_end_date = DateTime.Parse(Request.Params["endDate"]),
create_date = DateTime.Parse(Request.Params["createDate"]),
customer_add_prove = "Proved",
total_payment = decimal.Parse(Request.Params["totalPayment"]),
active = true,
Policy = policyInfo,
Customer_Info = customerInfo
};
CheckoutInfo checkout = new CheckoutInfo()
{
CustomerPolicy = newCustomerPolicy,
Vehicle = newVehicle
};
Session["checkoutInfo"] = checkout;
return(RedirectToAction("CheckOutPage"));
}
public async Task PaymentAccepted(Guid correlationId)
{
await Audit("CheckoutService", $"CheckoutSaga | PaymentAccepted({correlationId}):Action", "The payment is accepted by the payment gateway.");
var result = await LoadFromStorage(correlationId);
_state = (State)result.Item1.SagaStatus;
_internalData = result.Item2;
_correlationId = correlationId;
await _machine.FireAsync(_receivedPaymentTrigger, correlationId);
}
public async Task Checkout(Guid correlationId, Guid orderId)
{
await Audit("CheckoutService", $"CheckoutSaga | Checkout({correlationId}, {orderId}):Action", "The order is checking out...");
var result = await LoadFromStorage(correlationId, orderId);
_state = (State)result.Item1.SagaStatus;
_internalData = result.Item2;
_correlationId = correlationId;
await _machine.FireAsync(_checkoutTrigger, correlationId);
}
private void Checkout_Load(object sender, EventArgs e)
{
checkoutInfo = new CheckoutInfo();
gridSelections.DataSource = checkoutInfo.SelectedItems;
gridReview.DataSource = checkoutInfo.SelectedItems;
gridSelections.RowsAdded += SelectionCountChanged;
gridSelections.RowsRemoved += SelectionCountChanged;
TransitionToMemberLookup();
}
//create a payment using an APIContext
private Payment CreatePayment(APIContext apiContext, string redirectUrl)
{
CheckoutInfo checkout = (CheckoutInfo)Session["checkoutInfo"];
var lsItem = new ItemList()
{
items = new List <Item>()
};
lsItem.items.Add(new Item {
name = checkout.CustomerPolicy.Policy.policy_number, currency = "USD", price = checkout.CustomerPolicy.total_payment.ToString(), quantity = "1", sku = "sku"
});
var payer = new Payer()
{
payment_method = "paypal",
payer_info = new PayerInfo
{
email = "" //personal account
}
};
var redictUrl = new RedirectUrls()
{
cancel_url = redirectUrl,
return_url = redirectUrl
};
var detail = new Details()
{
tax = "0", shipping = "0", subtotal = checkout.CustomerPolicy.total_payment.ToString()
}; //subtotal: sum(price*quantity) if sum is incorrect, it will return an error 400.
var amount = new Amount()
{
currency = "USD", details = detail, total = checkout.CustomerPolicy.total_payment.ToString()
}; //total= tax + shipping + subtotal
var transList = new List <Transaction>();
transList.Add(new Transaction
{
description = "Payment",
invoice_number = Convert.ToString((new Random()).Next(100000)),
amount = amount,
item_list = lsItem,
});
this.payment = new Payment()
{
intent = "sale",
payer = payer,
transactions = transList,
redirect_urls = redictUrl
};
return(this.payment.Create(apiContext));
}
public void Create_Order_Infomation(CheckoutInfo model)
{
// create customer base on delivery info
var customer_Id = Create_Customer(model.BillingInfo);
// add to order table
var order_Id = Create_Order(customer_Id, model);
// add to order details table
foreach (var item in model.CartItems)
{
var order_Detail = Create_Order_Detail(order_Id, item);
}
}
/// <summary>
///
/// </summary>
/// <param name="idDocument"></param>
/// <param name="documentNumber"></param>
/// <param name="checkOutStatus"></param>
/// <returns></returns>
public bool IsCheckedOut(string idDocument, string documentNumber, out string ownerUser)
{
ownerUser = string.Empty;
CheckoutInfo info = this.GetDctmCheckOutInfo(documentNumber);
if (info != null)
{
ownerUser = info.UserName;
return(info.IsCheckedOut);
}
else
{
return(false);
}
}
/// <summary>
/// Reperimento dei metadati sullo stato del checkout del documento
/// </summary>
/// <param name="idDocument"></param>
/// <param name="documentNumber"></param>
/// <returns></returns>
public CheckOutStatus GetCheckOutStatus(string idDocument, string documentNumber)
{
CheckOutStatus retValue = null;
CheckoutInfo dctmCheckOutInfo = this.GetDctmCheckOutInfo(documentNumber);
if (dctmCheckOutInfo.IsCheckedOut)
{
string dctmId = ((ObjectId)dctmCheckOutInfo.Identity.Value).Id;
retValue = this.GetCheckOutStatus(dctmId, idDocument, documentNumber);
}
return(retValue);
}
public void AddCustomerPolicy()
{
CheckoutInfo checkout = (CheckoutInfo)Session["checkoutInfo"];
Vehicle_Info vehicleInfo = checkout.Vehicle;
Customer_Policy customerPolicy = checkout.CustomerPolicy;
VehicleinfoViewModel vehicle = new VehicleinfoViewModel()
{
address = vehicleInfo.address,
brandid = vehicleInfo.brand_id,
eginenumber = vehicleInfo.engine_number,
framenumber = vehicleInfo.frame_number,
modelid = vehicleInfo.model_id,
ownername = vehicleInfo.owner_name,
ratebycondition = vehicleInfo.rate_by_condition,
vehiclecondition = vehicleInfo.vehicle_condition,
vehiclenumber = vehicleInfo.vehicle_number,
version = vehicleInfo.version
};
VehicleinfoDAORequest request1 = new VehicleinfoDAORequest();
request1.Add(vehicle);
VehicleinfoViewModel vehicle2 = request1.GetByAllNumber(vehicle.framenumber, vehicle.eginenumber, vehicle.vehiclenumber);
CustomerpolicyViewModel cPolicy = new CustomerpolicyViewModel()
{
active = customerPolicy.active,
createdate = customerPolicy.create_date,
customeraddprove = customerPolicy.customer_add_prove,
customerid = (int)customerPolicy.customer_id,
policyenddate = customerPolicy.policy_end_date,
policyid = (int)customerPolicy.policy_id,
policystartdate = customerPolicy.policy_start_date,
TotalPayment = customerPolicy.total_payment,
vehicleid = vehicle2.id
};
CustomerpolicyDAORequest request2 = new CustomerpolicyDAORequest();
request2.Add(cPolicy);
}
public IActionResult LoginOrAnonymous(CheckoutInfo checkoutInfo)
{
if (User.Identity.IsAuthenticated)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = _context.Users.FirstOrDefault(x => x.Id == userId);
var order = _context.Order
.Include(x => x.Basket)
.ThenInclude(y => y.Items)
.ToList().Last();
order.User = user;
_context.AddOrUpdate(order);
_context.SaveChanges();
var chOutInfo = new CheckoutInfo
{
FirstName = user.FirstName,
LastName = user.LastName,
PostingAddress = user.PostingAddress,
PostalCode = user.PostalCode,
City = user.City,
Email = user.Email,
PhoneNumber = Convert.ToInt32(user.PhoneNumber),
OrderId = order.OrderId
};
_context.AddOrUpdate(chOutInfo);
_context.AddOrUpdate(order);
_context.SaveChanges();
return(RedirectToAction("Payment", "Orders", chOutInfo));
}
ViewData["ReturnUrl"] = HttpContext.Request.GetUri().AbsolutePath;
return(View(checkoutInfo));
}
public ActionResult tryCheckout(CheckoutInfo info)
{
string id = info.purchaseId ?? purchaseConfig.defaultPurchaseId;
PurchaseData purchase = findPurchaseData(PaymentController.countryToPurchases, id);
ActionResult res = null;
try
{
var customer = customerService.Create(new CustomerCreateOptions
{
Email = info.email,
SourceToken = info.sourceToken
});
var charge = chargeService.Create(new ChargeCreateOptions
{
Amount = purchase.price.amount,
Description = purchase.name,
Currency = purchase.price.currency,
CustomerId = customer.Id
});
if (charge != null)
{
if (charge.Paid)
{
//add credits to db user here
}
string chargeString = JsonConvert.SerializeObject(charge);
res = new ContentResult {
Content = chargeString, ContentType = "application/json"
};
}
} catch (Exception e)
{
res = null;
}
return(res);
}
public async Task <IActionResult> CheckoutInfo([Bind("Id, OrderId,FirstName,LastName,Email,PostingAddress,PostalCode,City,PhoneNumber")] CheckoutInfo checkoutInfo)
{
if (ModelState.IsValid)
{
try
{
_context.CheckoutInfo.Update(checkoutInfo);
await _context.SaveChangesAsync();
return(RedirectToAction("Payment", checkoutInfo));
}
catch (DbUpdateConcurrencyException exc)
{
_logger.LogError(exc.ToString());
}
return(RedirectToAction(nameof(Index)));
}
return(View("LoginOrAnonymous", checkoutInfo));
}
private int updateUserCredits(CheckoutInfo info, PurchaseData purchase, Charge charge)
{
int res = -1;
User user = userRepository.GetById(info.userId);
res = user.Credits;
if (
charge != null &&
charge.Paid
)
{
user.Credits += purchase.credits;
userRepository.Update(user);
res = user.Credits;
}
return(res);
}
private async Task <Tuple <SagaInfo, CheckoutInfo> > LoadFromStorage(Guid correlationId, Guid?orderId = null)
{
var sagaInfo = await _repository.GetByIdAsync(correlationId);
CheckoutInfo internalData;
if (sagaInfo != null)
{
internalData = sagaInfo.Data.ToObject <CheckoutInfo>();
}
else
{
if (!orderId.HasValue)
{
throw new Exception("Need to have an order id for the first time.");
}
var order = await _restClient.GetAsync <Order>("order_service", $"/api/orders/{orderId.Value}");
internalData = new CheckoutInfo
{
OrderId = order.Id,
CustomerId = order.CustomerId,
EmployeeId = order.EmployeeId,
OrderDate = order.OrderDate,
OrderStatus = (int)order.OrderStatus,
Products = order.OrderDetails.Select(x => new ProductInfo
{
ProductId = x.ProductId,
Quantity = x.Quantity
}).ToList()
};
var saga = new SagaInfo
{
Id = correlationId, // correlation id
Data = internalData.ToString <CheckoutInfo>()
};
sagaInfo = await _repository.AddAsync(saga);
}
return(new Tuple <SagaInfo, CheckoutInfo>(sagaInfo, internalData));
}
private static Charge performCharge(CheckoutInfo info, PurchaseData purchase)
{
Charge res = null;
var customer = customerService.Create(new CustomerCreateOptions
{
Email = info.email,
SourceToken = info.sourceToken
});
var amountMultiplier = getUnitMultiplier(purchase);
res = chargeService.Create(new ChargeCreateOptions
{
Amount = purchase.price.amount * amountMultiplier,
Currency = purchase.price.currency,
Description = purchase.name,
CustomerId = customer.Id
});
return(res);
}
private int Create_Order(int Customer_Id, CheckoutInfo model)
{
try
{
double?total_Money = 0;
foreach (var item in model.CartItems)
{
if (item.Price == null)
{
item.Price = 0;
}
;
var item_total_price = item.Price * item.Quantity;
total_Money += item_total_price;
}
object[] SqlParams =
{
new SqlParameter("@Customer_Id", Customer_Id),
new SqlParameter("@Delivery_City_Id", model.BillingInfo.City_ID),
new SqlParameter("@Delivery_District_Id", model.BillingInfo.District_ID),
new SqlParameter("@Delivery_Address", model.BillingInfo.Delivery_Address),
new SqlParameter("@Total_Money", total_Money),
new SqlParameter("@Order_Status", 1),
new SqlParameter("@Notes", model.BillingInfo.Notes)
};
var res = context.Database.SqlQuery <int>("Sp_Create_Order @Customer_Id, @Delivery_City_Id, @Delivery_District_Id, @Delivery_Address, @Total_Money, @Order_Status, @Notes", SqlParams).FirstOrDefault();
return(res);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
return(0);
}
}
public override async Task <IActionResult> Execute(object id, IFormCollection formCollection = null)
{
var context = this.Context;
var basketId = 0;
if (this.Controller.HttpContext.Session.GetInt32("BasketId") != null)
{
basketId = this.Controller.HttpContext.Session.GetInt32("BasketId").Value;
}
var basket = context.Baskets
.Include(x => x.Items)
.ThenInclude(y => y.BasketItemIngredients)
.Include(z => z.Items)
.ThenInclude(h => h.Dish)
.ThenInclude(j => j.DishIngredients)
.ThenInclude(k => k.Ingredient)
.FirstOrDefault(x => x.BasketId == basketId);
var previousOrder = context.Order
.Include(x => x.Basket)
.FirstOrDefault(x => x.BasketId == basketId);
var order = new Order();
if (previousOrder != null)
{
order = previousOrder;
}
else
{
order.Basket = basket;
}
if (this.Controller.User.Identity.IsAuthenticated)
{
if (this.Controller.HttpContext.Session.GetInt32("LoggedInBefore") != null)
{
order = context.Order
.Include(x => x.Basket)
.ThenInclude(y => y.Items)
.ToList().Last();
}
var userId = this.Controller.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = context.Users.FirstOrDefault(x => x.Id == userId);
order.User = user;
context.AddOrUpdate(order);
await context.SaveChangesAsync();
var chOutInfo = new CheckoutInfo
{
FirstName = user.FirstName,
LastName = user.LastName,
PostingAddress = user.PostingAddress,
PostalCode = user.PostalCode,
City = user.City,
Email = user.Email,
PhoneNumber = Convert.ToInt32(user.PhoneNumber),
OrderId = order.OrderId
};
context.AddOrUpdate(chOutInfo);
context.AddOrUpdate(order);
order.BasketId = basketId;
await context.SaveChangesAsync();
this.Controller.HttpContext.Session.Remove("LoggedInBefore");
return(Controller.RedirectToAction("Payment", "Orders", chOutInfo));
}
context.AddOrUpdate(order);
await context.SaveChangesAsync();
var checkoutInfo = new CheckoutInfo {
OrderId = order.OrderId
};
order.BasketId = basketId;
await context.SaveChangesAsync();
this.Controller.HttpContext.Session.SetInt32("LoggedInBefore", 1);
return(this.Controller.RedirectToAction("LoginOrAnonymous", "Orders", checkoutInfo));
}
public ActionResult CheckOutPage()
{
CheckoutInfo checkout = (CheckoutInfo)Session["checkoutInfo"];
return(View(checkout));
}
protected override void When()
{
workingArea = Path.Combine(GitTestSupport.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(workingArea);
sourceRevision = _driver.GetSourceRevision(revision1.Revision, workingArea );
}
