private void SetResult(Boolean result, String message)
{
var isBackgroundCheck = Request.ParseCheckboxValue("backgroundcheck") ?? false;
if (isBackgroundCheck)
{
var checkoutResult = new CheckoutResult
{
Result = result,
Message = message
};
Helper.RespondWithJsonObject(checkoutResult, Response);
}
else
{
if (result)
{
var order = Flyer.ToOrder();
order.Save();
WizardFlyer.DeleteFlyer();
Response.SuppressContent = true;
Response.Redirect("~/cart.aspx?orderid=" + order.order_id.ToString());
}
else
{
throw new Exception(message);
}
}
}
private void CompleteCheckout()
{
try
{
// lookup for payment form
IPaymentMethod methodObj = (IPaymentMethod)FindControl(CTL_PAYMENT_FORM);
//
CheckoutDetails details = methodObj.GetCheckoutDetails();
//
CheckoutResult result = StorefrontHelper.CompleteCheckout(ecPanelRequest.ContractId,
ecPanelRequest.InvoiceId, ecPanelRequest.PaymentMethod, details);
//
if (!result.Succeed)
{
ShowErrorMessage(result.StatusCode);
return;
}
//
ecUtils.Navigate("ecOrderComplete", true);
}
catch (Exception ex)
{
ShowErrorMessage("COMPLETE_CHECKOUT", ex);
}
}
protected virtual void PostProcessCheckout(CheckoutResult result)
{
// check order payment result status
if (result.Succeed)
{
// go to the order success page
Response.Redirect(RedirectUrl + OrderCompleteUri);
}
else
{
// go to order failed page
Response.Redirect(RedirectUrl + OrderFailedUri);
}
}
protected virtual void ProcessCheckout(string methodName, CheckoutDetails details)
{
try
{
PreProcessCheckout(details);
// perform order payment
CheckoutResult result = StorefrontHelper.CompleteCheckout(details[contractKey], invoiceId, methodName, details);
// post process order result
PostProcessCheckout(result);
}
catch (Exception ex)
{
// Output error message into the trace
Trace.Write("ECOMMERCE", "COMPLETE_CHECKOUT_ERROR", ex);
// display raw stack trace in case of error
Response.Write(PortalUtils.GetSharedLocalizedString("Ecommerce", "Error.CHECKOUT_GENERAL_FAILURE"));
}
}
public virtual void TestFileModeChangeAndContentChangeConflict()
{
if (!FS.DETECTED.SupportsExecute())
{
return;
}
Git git = Git.Wrap(db);
// Add non-executable file
FilePath file = WriteTrashFile("file.txt", "a");
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("commit1").Call();
NUnit.Framework.Assert.IsFalse(db.FileSystem.CanExecute(file));
// Create branch
git.BranchCreate().SetName("b1").Call();
// Make file executable
db.FileSystem.SetExecute(file, true);
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("commit2").Call();
// Verify executable and working directory is clean
Status status = git.Status().Call();
NUnit.Framework.Assert.IsTrue(status.GetModified().IsEmpty());
NUnit.Framework.Assert.IsTrue(status.GetChanged().IsEmpty());
NUnit.Framework.Assert.IsTrue(db.FileSystem.CanExecute(file));
WriteTrashFile("file.txt", "b");
// Switch branches
CheckoutCommand checkout = git.Checkout().SetName("b1");
try
{
checkout.Call();
NUnit.Framework.Assert.Fail("Checkout exception not thrown");
}
catch (NGit.Api.Errors.CheckoutConflictException)
{
CheckoutResult result = checkout.GetResult();
NUnit.Framework.Assert.IsNotNull(result);
NUnit.Framework.Assert.IsNotNull(result.GetConflictList());
NUnit.Framework.Assert.AreEqual(1, result.GetConflictList().Count);
NUnit.Framework.Assert.IsTrue(result.GetConflictList().Contains("file.txt"));
}
}
protected void Page_Load(object sender, EventArgs e)
{
Context.Trace.Write("PayPalIpnHandler called");
Exceptions.LogException(new Exception("PayPalIpnHandler Called with keys: " + Request.Params.AllKeys.ToCsv()));
InitializeEntitySpaces();
int?orderId = WA.Parser.ToInt(Request.Params["custom"]);
Exceptions.LogException(new Exception("PayPalIpnHandler : Order ID = " + orderId));
Order pendingOrder = Order.GetOrder(orderId.GetValueOrDefault(-1));
if (pendingOrder != null)
{
Exceptions.LogException(new Exception("PayPalIpnHandler : Found pending order"));
DataModel.Store store = pendingOrder.UpToStoreByStoreId;
StoreContext storeContext = new StoreContext(Request, store.Id.Value);
PayPalStandardProvider payPalStandard = new PayPalStandardProvider(store.GetPaymentProviderConfig(PaymentProviderName.PayPalStandard));
if (payPalStandard.IsIpnResponse(Request))
{
Exceptions.LogException(new Exception("PayPalIpnHandler : Is Valid IPN request, processing IPN variables..."));
OrderController orderController = new OrderController(storeContext);
CheckoutResult checkoutResult = orderController.CheckoutWithPayPalStandardCheckout(Request);
}
else
{
StringBuilder request = new StringBuilder();
foreach (var key in Request.Params.AllKeys)
{
request.AppendFormat("{0} = {1} <br />{2}", key, Request.Params[key], Environment.NewLine);
}
Exceptions.LogException(new Exception("PayPalIpnHandler : NOT AN IPN RESPONSE. Request = " + request.ToString()));
}
}
else
{
//Exceptions.LogException(new Exception("PayPalIpnHandler : pendingOrder IS NULL!"));
}
}
protected override void PostProcessCheckout(CheckoutResult result)
{
// 2Checkout workaround for Direct Return = Yes
Response.Clear();
// write refresh html
if (!result.Succeed)
{
Response.Write(
"<html><head><META http-equiv=\"refresh\" content=\"0;" +
"URL=" + RedirectUrl + CheckoutBasePage.OrderFailedUri + "\"></head></html>"
);
}
else
{
Response.Write(
"<html><head><META http-equiv=\"refresh\" content=\"0;" +
"URL=" + RedirectUrl + CheckoutBasePage.OrderCompleteUri + "\"></head></html>"
);
}
}
public IActionResult CheckoutALibraryBook(Guid bookId)
{
ILibraryBook book = _libraryService.Book(bookId);
string message = string.Empty;
if (book != null)
{
DateTime dueDate = DateTime.Now.AddDays(30);
CheckoutResult result = book.Checkout();
if (result.CheckedOutResultStatus == CheckedOutResultStatus.Ok)
{
return(Ok(new { BookId = bookId, DueDate = dueDate }));
}
message = result.Message;
}
return(BadRequest(message));
}
/// <summary>
/// Checks out a selected document and returns back result of checkout. While checkout of selected document checked out and state file will be created in
/// checkout directory.
/// </summary>
/// <param name="document">Document, that have to be checked out.</param>
/// <returns>
/// Result of checkout operation.
/// </returns>
public CheckoutResult Checkout(FWDocument document)
{
CheckoutResult checkOutResult = new CheckoutResult()
{
FWDocument = document, Success = false
};
try
{
bool existsDocForCheckOut = (document != null);
bool existsDocUrl = (document != null && document.Version != null && !string.IsNullOrEmpty(document.Version.Url));
bool existsIxConn = (document.Conn != null);
if (existsDocForCheckOut && existsDocUrl && existsIxConn)
{
// Delete not more checked out documents in checkout directory
ForceCleanup();
// Actualize data of document
document.Refresh();
FWConnection ixConn = document.Conn;
// Exists checkout file already
bool existsCheckedOutFile = (!string.IsNullOrEmpty(document.CheckedoutFile) && File.Exists(document.CheckedoutFile));
// If checkout file already exists
if (existsCheckedOutFile)
{
// If document lock, not exists for currently user set one
if (document.LockId == -1)
{
FWDocument lockedDocument = ixConn.Content.LockDocument(document.Id);
if (lockedDocument.LockId == ixConn.Session.User.id)
{
checkOutResult.FWDocument = lockedDocument;
checkOutResult.Success = true;
}
else
{
checkOutResult.Message = string.Format("Das Dokument {0} kann nicht zur Bearbeitung ausgecheckt werden, da das Sperren des Dokuments für die Bearbeitung nicht erfolgreich durchgeführt werden konnte.", document.Name);
}
}
else
{
if (document.LockId == ixConn.Session.User.id)
{
checkOutResult.FWDocument = document;
checkOutResult.Success = true;
}
else
{
checkOutResult.Message = string.Format("Das Dokument {0} kann nicht zur Bearbeitung ausgecheckt werden, da dieses bereits durch einen anderen Benutzer für die Bearbeitung gesperrt worden ist.", document.Name);
}
}
}
else
{
if (document.LockId == -1)
{
FWDocument lockedDocument = ixConn.Content.LockDocument(document.Id);
if (lockedDocument.LockId == ixConn.Session.User.id)
{
// Create checkout file and state file for checked out document
CreateCheckedOutDocumentFiles(lockedDocument);
lockedDocument.Refresh();
checkOutResult.FWDocument = lockedDocument;
checkOutResult.Success = true;
}
else
{
checkOutResult.Message = string.Format("Das Dokument {0} kann nicht zur Bearbeitung ausgecheckt werden, da das Sperren des Dokuments für die Bearbeitung nicht erfolgreich durchgeführt werden konnte.", document.Name);
}
}
else if (document.LockId == ixConn.Session.User.id)
{
// Create checkout file and state file for checked out document
CreateCheckedOutDocumentFiles(document);
document.Refresh();
checkOutResult.FWDocument = document;
checkOutResult.Success = true;
}
else
{
checkOutResult.Message = string.Format("Das Dokument {0} kann nicht zur Bearbeitung ausgecheckt werden, da es durch einen anderen Benutzer bereits für die Bearbeitung gesperrt worden ist.", document.Name);
}
}
}
else
{
checkOutResult.Message = "Das Dokument kann nicht zur Bearbeitung ausgecheckt werden. Mögliche Ursachen: Dokument existiert nicht, keine Verbindung zum Indexserver oder die Url des Dokuments ist nicht vorhanden.";
}
}
catch (Exception ex)
{
checkOutResult.Success = false;
checkOutResult.Message = "Das Auschecken des Dokuments zur Bearbeitung ist aufgrund des folgenden Fehlers fehlgeschlagen. Fehler: " + ex.Message;
}
return(checkOutResult);
}
private void PlaceOrder()
{
if (checkoutOrderInfo != null)
{
bool doSuccessRedirect = false;
string nextPageFlashMsg = "";
CheckoutResult checkoutResult = null;
checkoutOrderInfo.OrderNotes = txtOrderNotes.Text;
try
{
OrderController orderController = new OrderController(StoreContext);
if (checkoutOrderInfo.PaymentProvider == PaymentProviderName.PayPalExpressCheckout)
{
//---- PayPal Express Checkout
checkoutResult = orderController.CheckoutWithPayPalExpressCheckout(checkoutOrderInfo.PayPalVariables);
}
else
{
//---- Non-PayPal Process
checkoutResult = orderController.CheckoutWithOnSitePayment(checkoutOrderInfo);
}
if (checkoutResult.Errors.Count > 0)
{
StringBuilder errorList = new StringBuilder();
errorList.Append("<ul>");
checkoutResult.Errors.ForEach(e => errorList.AppendFormat("<li>{0}</li>", e));
errorList.Append("</ul>");
msgFlash.Visible = true;
msgFlash.InnerHtml = string.Format(@"Oh no! Something went wrong when we tried to process your order: {0}", errorList);
LogToDnnEventLog(string.Format(@"Checkout ERROR. PortalId: {0} StoreId: {1} OrderId : {2}. Errors: {3}", PortalId, StoreContext.CurrentStore.Id, (checkoutResult.SubmittedOrder != null) ? checkoutResult.SubmittedOrder.Id.ToString() : "", checkoutResult.Errors.ToCsv()));
doSuccessRedirect = false;
}
else if (checkoutResult.Warnings.Count > 0)
{
nextPageFlashMsg = string.Format(@"We received your order successfully, but we encountered some problems during processing: {0}", checkoutResult.Warnings.ToCsv());
LogToDnnEventLog(string.Format(@"Checkout WARNING. PortalId: {0} StoreId: {1} OrderId : {2}. Errors: {3}", PortalId, StoreContext.CurrentStore.Id, (checkoutResult.SubmittedOrder != null) ? checkoutResult.SubmittedOrder.Id.ToString() : "", checkoutResult.Errors.ToCsv()));
// still show "complete" page if we have warnings
doSuccessRedirect = true;
}
else if (checkoutResult.SubmittedOrder != null)
{
if (checkoutResult.SubmittedOrder.OrderStatus == OrderStatusName.Completed || checkoutResult.SubmittedOrder.OrderStatus == OrderStatusName.Processing)
{
doSuccessRedirect = true;
}
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
msgFlash.Visible = true;
msgFlash.InnerHtml = string.Format(@"Oops! An unexpected error has occurred while trying to process your order. Error: {0} {1}", ex.Message, ex.StackTrace);
}
if (checkoutResult != null)
{
// We need to Response.Redirect() outside of the try/catch block to avoid throwing a "Thread was being aborted exception"
if (doSuccessRedirect)
{
Response.Redirect(StoreUrls.CheckoutCompleteForOrder(checkoutResult.SubmittedOrder.CreatedFromCartId.Value, nextPageFlashMsg));
}
}
else
{
Exceptions.LogException(new ApplicationException("CheckoutResult is NULL"));
msgFlash.Visible = true;
msgFlash.InnerHtml = string.Format(@"Oops! An unexpected error has occurred while trying to process your order. Error: CheckoutResult is NULL");
}
}
else
{
Exceptions.LogException(new ApplicationException("CheckoutOrderInfo is NULL in the Session!"));
msgFlash.Visible = true;
msgFlash.InnerHtml = string.Format(@"Oops! An unexpected error has occurred while trying to process your order. Error: CheckoutOrderInfo is NULL");
}
}
/// <summary>
/// Try to read a Sord object.
/// </summary>
/// <param name="objId">Object ID</param>
/// <param name="accessMode">A combination of the FWAccessMode constants.</param>
/// <param name="docAction">DocAction.
/// If the Sord object is a <c>FWDocument</c> and the parameter is set to <c>DocAction.EditDocument</c> and FWAccessMode.Lock is set, the document will copied to the checkout-directory.
/// Th eparameter will be ignored, if the Sord object is a <c>FWFolder</c>.
/// </param>
/// <returns>Sord object or null, if the object does not exist and accessMode does not include MustExist.</returns>
/// <exception>IOException: object already locked, access denied, etc.</exception>
public virtual FWSord TryGetSord(string objId, FWAccessModes accessMode, DocAction docAction)
{
FWSord xsord = null;
bool exceptionOccured = false;
FWSord tmpSord = null;
try
{
//GetSord(objId);
LockZ lockZ = FWLockMode.MakeLockZ(FWAccessModes.MustExist);
Sord sord = Conn.Ix.checkoutDoc(objId, null, EditZ, lockZ).sord;
sord.changedMembers = EditZ.bset;
if (sord.id == 1 || sord.type < SordC.LBT_DOCUMENT)
{
tmpSord = ClassFactory.NewFolder(sord);
}
else
{
tmpSord = ClassFactory.NewDocument(sord);
}
}
catch (Exception e)
{
exceptionOccured = true;
if ((accessMode & FWAccessModes.MustExist) != 0)
{
throw e;
}
if (e.Message.IndexOf("[ELOIX:" + IXExceptionC.NOT_FOUND) < 0)
{
throw e;
}
}
if (tmpSord != null && tmpSord.IsDocument() && docAction == DocAction.EditDocument)
{
CheckoutResult result = checkedOutDocumentsManagerVal.Checkout(tmpSord as FWDocument);
if (result.Success)
{
xsord = result.FWDocument;
}
}
else if (!exceptionOccured)
{
try
{
LockZ lockZ = FWLockMode.MakeLockZ(accessMode);
Sord sord = Conn.Ix.checkoutDoc(objId, null, EditZ, lockZ).sord;
sord.changedMembers = EditZ.bset;
if (sord.id == 1 || sord.type < SordC.LBT_DOCUMENT)
{
xsord = ClassFactory.NewFolder(sord);
}
else
{
xsord = ClassFactory.NewDocument(sord);
}
}
catch (Exception e)
{
if ((accessMode & FWAccessModes.MustExist) != 0)
{
throw e;
}
if (e.Message.IndexOf("[ELOIX:" + IXExceptionC.NOT_FOUND) < 0)
{
throw e;
}
}
}
return(xsord);
}
protected void Page_Load(object sender, EventArgs e)
{
pnlOrderDetails.Visible = false;
LoadResourceFileSettings();
if (!IsPostBack)
{
PayPalStandardProvider payPalStandard =
new PayPalStandardProvider(
StoreContext.CurrentStore.GetPaymentProviderConfig(PaymentProviderName.PayPalStandard));
bool isPayPalIpn = false;
bool isPayPalReferrer = false;
bool isPayPalStandardReturn = false;
if (payPalStandard.IsEnabled)
{
isPayPalIpn = payPalStandard.IsIpnResponse(Request);
isPayPalReferrer = (Request.UrlReferrer != null)
? Request.UrlReferrer.ToString().Contains("paypal.com")
: false;
isPayPalStandardReturn = Request.Params["ppstdreturn"] != null;
}
Guid?completedOrderId = WA.Parser.ToGuid(Request.Params["dsoid"]);
if (completedOrderId.HasValue && !(isPayPalReferrer || isPayPalIpn))
{
// load an on-site order
OrderQuery q = new OrderQuery();
q.Where(q.CreatedFromCartId == completedOrderId.Value);
q.es.Top = 1;
order.Load(q);
}
else if (isPayPalReferrer || isPayPalIpn)
{
OrderController orderController = new OrderController(StoreContext);
CheckoutResult checkoutResult = orderController.CheckoutWithPayPalStandardCheckout(Request);
if (checkoutResult != null)
{
order = checkoutResult.SubmittedOrder;
}
}
//bool clientHasCartIdCookie = order.CreatedFromCartId.Value == StoreContext.CartId;
//if (UserInfo.IsSuperUser || UserInfo.IsInRole("Administrator") || UserInfo.UserID == order.UserId)
//if (UserInfo.IsSuperUser || UserInfo.IsInRole("Administrator") || clientHasCartIdCookie)
//{
pnlOrderDetails.Visible = true;
pnlOrderReceipt.Visible = true;
if (order.Id.HasValue)
{
ShowDigitalDownloads();
if (order.PaymentStatus == PaymentStatusName.Pending)
{
pnlDigitalDownloads.Visible = false;
}
if (isPayPalStandardReturn)
{
pnlOrderReceipt.Visible = false;
}
else
{
LoadOrderReceipt();
}
}
else
{
//ShowFlash("Unable to find order");
//flash.Text = "Unable to find order";
ShowFlash("Could not load Order from DB");
//flash.Text = "Could not load Order from DB";
pnlOrderReceipt.Visible = false;
pnlDigitalDownloads.Visible = false;
}
//}
}
}
static void Main(string[] args)
{
List <Book> availableBooks = Book.AvailableBooks;
List <Student> CheckedOutBooks = new List <Student>();
string bookSelectionStr;
int bookSelectionInt;
double num;
System.Console.Write("Enter your name: ");
string name = Console.ReadLine();
Student student = new Student(name);
System.Console.WriteLine();
System.Console.WriteLine("Welcome {0}! You can check out maximum {1} books:", student.Name, Student.MaxNumOfCheckOut);
//Write your code here
//Displays the list of books:
for (int i = 0; i < availableBooks.Count; i++) // as long as there is a book in list
{
Console.Write("{0}. {1} \n", i, availableBooks[i].Title);
}
//user chooses the book:
do
{
Console.Write("Enter the book you want to check out: (0 - {0}) or enter -1 to finish: ", availableBooks.Count - 1);
bookSelectionStr = Console.ReadLine();
//breaking out of the loop:
if (bookSelectionStr == "-1")
{
break;
}
else
{
//validating answer:
if ((!double.TryParse(bookSelectionStr, out num)) || (num < -1) || (double.Parse(bookSelectionStr) > availableBooks.Count - 1))
{
Console.Write("\nNumber is not valid. Please try it again. \n");
continue;
}
else
{
//real code:
bookSelectionInt = int.Parse(bookSelectionStr);
//instantiating book:
Book newBook = availableBooks[bookSelectionInt];
CheckoutResult checkedResult = student.CheckoutBook(newBook);
if (checkedResult == CheckoutResult.SUCCESS) //book is added to checked out list
{
Console.WriteLine("\nYou have checked out {0}. You can check out {1} more book(s).\n", availableBooks[bookSelectionInt].Title, 3 - student.CheckedOutBooks.Count);
if (student.CheckedOutBooks.Count == 3)
{
Console.WriteLine("This was your third (and last) book selected.");
break;
}
else
{
availableBooks.RemoveAt(bookSelectionInt);
for (int i = 0; i < availableBooks.Count; i++) //printing available books list:
{
Console.Write("{0}. {1} \n", i, availableBooks[i].Title);
}
}
}
if (checkedResult == CheckoutResult.EXCEED_MAX_CHECKOUT)
{
Console.Write("You have exceeded the maximum checkout number. ");
break;
}
}
}
} while (bookSelectionStr != "-1");
//Write your code here
//Printing checked out list:
Console.WriteLine("\nYou have checked out the following books:");
for (int i = 0; i < student.CheckedOutBooks.Count; i++) // as long as there is a book in list
{
//Console.WriteLine("why not?");
Console.Write("{0}. {1} \n", i, student.CheckedOutBooks[i].Title);
}
Console.Write("\nPlease press any key to finish...");
System.Console.ReadLine();
}