public ActionResult Cancelled(int?id)
        {
            if (!id.HasValue)
            {
                LogError(log, string.Format("Felaktigt regId: {0} i cancel.", id));
                return(ShowError(log, "Kunde inte återskapa dina uppgifter.", true, new Exception("Felaktigt regId: " + id + " vid cancel.")));
            }

            var registrering = smuService.GetRegistrering(id.Value, false);

            if (registrering == null)
            {
                LogError(log, "Payson betalning avbruten och ingen registrering i Session hittades.");
                return(ShowError(log, "Betalningen avbröts av okänd anledning", true, new Exception("Payson betalning avbruten och ingen registrering i Session hittades.")));
            }

            var org = smuService.HamtaOrganisation(registrering.Evenemang.OrganisationsId);

            var api = new PaysonApi(org.Betalningsmetoder.PaysonUserId, org.Betalningsmetoder.PaysonUserKey, ApplicationId, false);

            var response = api.MakePaymentDetailsRequest(new PaymentDetailsData(registrering.PaysonToken));

            var evenemangsId = registrering.EvenemangsId;

            // Ta bort temporär registrering
            smuService.TabortRegistrering(registrering);

            Session["VM"] = null;

            return(ShowPaymentError("Betalningen avbruten.", response.NvpContent, evenemangsId.Value));
        }
Exemple #2
0
        public ActionResult IPN(string orderGuid)
        {
            Request.InputStream.Position = 0;
            var content = new StreamReader(Request.InputStream).ReadToEnd();

            var state = repository.GetPurchaseState(orderGuid);

            if (state != null)
            {
                var api      = new PaysonApi(state.UserId, state.UserKey, ApplicationId, true);
                var response = api.MakeValidateIpnContentRequest(content);
                if (response.Success)
                {
                    var status = response.ProcessedIpnMessage.PaymentStatus.HasValue
                                     ? response.ProcessedIpnMessage.PaymentStatus.ToString()
                                     : "N/A";
                    state.Updates[DateTime.Now] = "IPN: " + status;
                    state.LatestStatus          = status;
                }
                else
                {
                    state.Updates[DateTime.Now] = "IPN: IPN Failure";
                    state.LatestStatus          = "Failure";
                }
            }

            return(new EmptyResult());
        }
Exemple #3
0
        public ActionResult Returned(string orderGuid)
        {
            var state = repository.GetPurchaseState(orderGuid);

            if (state != null)
            {
                var api      = new PaysonApi(state.UserId, state.UserKey, ApplicationId, true);
                var response = api.MakePaymentDetailsRequest(new PaymentDetailsData(state.Token));

                if (response.Success)
                {
                    var status = response.PaymentDetails.PaymentStatus.HasValue
                                     ? response.PaymentDetails.PaymentStatus.ToString()
                                     : "N/A";
                    state.Updates[DateTime.Now] = "ReturnUrl: " + status;
                    state.LatestStatus          = status;
                }
                else
                {
                    ViewBag.Errors = response.ErrorMessages;
                    return(View("Index", GetDefaultPayViewModel()));
                }
            }

            return(View("Result", state));
        }
        /// <summary>
        /// Metod som kallas när betalningen är klar
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult Returned(int?id)
        {
            LogDebug(log, string.Format("Returned id: {0}", id));

            if (!id.HasValue)
            {
                LogError(log, string.Format("Felaktigt angivet regId: {0}", id));
                return(ShowError(log, "Ett fel inträffade när betalningen slutfördes. Kontrollera i startlistan om er registrering genomförts", true, new Exception("Felaktigt angivet regId: " + id)));
            }

            var registration = smuService.GetRegistrering(id.Value, true);

            if (registration == null)
            {
                LogError(log, string.Format("Ingen registration hittad med id: {0} i Returned.", id));
                return(ShowError(log, "Ett fel inträffade när betalningen slutfördes. Kontrollera i startlistan om er registrering genomförts", true, new Exception("Ingen registration hittad med  id: " + id + " i Returned.")));
            }

            LogDebug(log, string.Format("Returned. Lagnamn: {0}", registration.Lagnamn));

            // If no payment message has been sent (IPN)
            if (!registration.HarBetalt)
            {
                var org = smuService.HamtaOrganisation(registration.Evenemang.OrganisationsId);

                var api = new PaysonApi(org.Betalningsmetoder.PaysonUserId, org.Betalningsmetoder.PaysonUserKey, ApplicationId, false);

                var response = api.MakePaymentDetailsRequest(new PaymentDetailsData(registration.PaysonToken));

                if (response.Success && (response.PaymentDetails.PaymentStatus == PaymentStatus.Completed ||
                                         response.PaymentDetails.PaymentStatus == PaymentStatus.Pending))
                {
                    if (!registration.HarBetalt)
                    {
                        smuService.HarBetalt(registration);
                        SkickaRegMail(registration);
                        Session["VM"] = null;
                    }
                }
                else
                {
                    LogDebug(log, string.Format("Deleting temp-registration with id: {0}", id));

                    var evenemangsId = registration.EvenemangsId;

                    // Remove the temporary registration
                    smuService.TabortRegistrering(registration);

                    return(ShowPaymentError("Error when payment returned.", response.NvpContent, evenemangsId.Value));
                }
            }

            ViewBag.ev = registration.Evenemang.Namn;
            return(RedirectToAction("BekraftelseBetalning", "signmeup", new { id = id }));
        }
        public JsonResult Validate(ValidateViewModel validateViewModel)
        {
            var api      = new PaysonApi(validateViewModel.UserId, validateViewModel.UserKey, ApplicationId, true);
            var response = api.MakeAccountDetailsRequest();

            if (response.Success)
            {
                return(Json(new { success = true, accountEmail = response.AccountDetails.AccountEmail, enabledForInvoice = response.AccountDetails.EnabledForInvoice, enabledForPaymentPlan = response.AccountDetails.EnabledForPaymentPlan }, JsonRequestBehavior.AllowGet));
            }
            return(Json(new { success = false, error = "Wrong credentials" }, JsonRequestBehavior.AllowGet));
        }
        public ActionResult Index(PaysonKontaktViewModel kontaktInfo, string prev)
        {
            if (!string.IsNullOrEmpty(prev))
            {
                return(RedirectToAction("BekraftaRegistrering", "SignMeUp"));
            }

            var SUPVM = Session["VM"] as SignMeUpVM;

            if (ModelState.IsValid)
            {
                try
                {
                    if (SUPVM == null)
                    {
                        return(ShowError(log, "Oväntat fel. Var god försök senare", true, new Exception("Ingen paysonViewModel i Session.")));
                    }

                    SUPVM.Kontaktinformation = kontaktInfo;

                    LogDebug(log, string.Format("Payment: Lagnamn: {0}", SUPVM.GetFaltvarde("Lagnamn")));

                    var evenemang = smuService.HamtaEvenemang(SUPVM.EvenemangsId);
                    var org       = evenemang.Organisation;

                    // Spara temporärt i databasen
                    var reg = smuService.Spara(SUPVM);
                    SUPVM.RegistreringsId = reg.Id;

                    PayData payData = SkapaPaysonPayData(SUPVM, org);

                    var api = new PaysonApi(org.Betalningsmetoder.PaysonUserId, org.Betalningsmetoder.PaysonUserKey, ApplicationId, false);

                    var response = api.MakePayRequest(payData);

                    if (response.Success)
                    {
                        SUPVM.PaysonToken = response.Token;
                        reg.PaysonToken   = response.Token;

                        smuService.UpdateraRegistrering(reg);

                        var forwardUrl = api.GetForwardPayUrl(response.Token);

                        Session["VM"] = SUPVM;

                        return(Redirect(forwardUrl));
                    }

                    Session["VM"] = SUPVM;

                    return(ShowPaymentError("Error when sending payment to payson.", response.NvpContent, SUPVM.EvenemangsId));
                }
                catch (Exception exception)
                {
                    var exc = new Exception("Ett fel inträffade i PaysonController Index metod.", exception);
                    LogError(log, "Exception in Index.", exception);
                    return(ShowError(log, "Oväntat fel vid betalning. Var god försök igen.", true, exc));
                }
            }

            Session["VM"] = SUPVM;
            ViewBag.ev    = SUPVM.EvenemangsNamn;
            return(View(kontaktInfo));
        }
        public ActionResult IPN(int?id)
        {
            var host = Request.Url.Host;

            if (!id.HasValue)
            {
                LogError(log, "IPN, id har inget värde");
                SendMail.SendErrorMessage("IPN, id har inget värde", host);
                return(new EmptyResult());
            }

            LogDebug(log, string.Format("IPN id: {0}", id));

            try
            {
                var registrering = smuService.GetRegistrering(id.Value, true);

                if (registrering != null)
                {
                    Request.InputStream.Position = 0;
                    var content = new StreamReader(Request.InputStream).ReadToEnd();

                    var org = smuService.HamtaOrganisation(registrering.Evenemang.OrganisationsId);
                    var api = new PaysonApi(org.Betalningsmetoder.PaysonUserId, org.Betalningsmetoder.PaysonUserKey, ApplicationId, false);

                    var response   = api.MakeValidateIpnContentRequest(content);
                    var statusText = response.ProcessedIpnMessage.PaymentStatus.HasValue
                                        ? response.ProcessedIpnMessage.PaymentStatus.ToString()
                                        : "N/A";
                    var status = response.ProcessedIpnMessage.PaymentStatus;

                    LogDebug(log, string.Format("IPN message, status: {0}. regId: {1} success: {2}",
                                                statusText, id, response.Success));

                    if (status == PaymentStatus.Completed)
                    {
                        if (!registrering.HarBetalt)
                        {
                            smuService.HarBetalt(registrering);
                            SkickaRegMail(registrering);
                            Session["VM"] = null;
                        }
                        else
                        {
                            LogDebug(log, "Registreringen var redan markerad som betald. Skickar inget meddelande.");
                        }
                    }
                    else
                    {
                        SendMail.SendErrorMessage("IPN message for non complete transaction. regId: " + id + ". Status: " + statusText, host);
                        LogDebug(log, string.Format("IPN message for non complete transaction. regId: {0}. Status: {1}", id, statusText));
                    }
                }
                else
                {
                    LogError(log, string.Format("Got IPN with wrong regId as query parameter: {0}", id));
                    SendMail.SendErrorMessage("Got IPN with wrong regId as query parameter: " + id, host);
                }
            }
            catch (Exception exc)
            {
                LogError(log, "Ett fel inträffade i IPN metoden.", exc);
                SendMail.SendErrorMessage(string.Format("Ett fel inträffade i IPN metoden. Exception: {0}", exc.ToString()), host);
            }

            return(new EmptyResult());
        }
Exemple #8
0
        public ActionResult Pay(PayViewModel payViewModel)
        {
            var orderGuid = Guid.NewGuid().ToString();

            // We remove port info to help when the site is behind a load balancer/firewall that does port rewrites.
            var scheme    = Request.Url.Scheme;
            var host      = Request.Url.Host;
            var oldPort   = Request.Url.Port.ToString();
            var returnUrl = Url.Action("Returned", "Checkout", new RouteValueDictionary(), scheme, host).Replace(oldPort, "") + "?orderGuid=" + orderGuid;

            var cancelUrl = Url.Action("Cancelled", "Checkout", new RouteValueDictionary(), scheme, host).Replace(oldPort, "");

            // When the shop is hosted by Payson the IPN scheme must be http and not https
            var ipnNotificationUrl = Url.Action("IPN", "Checkout", new RouteValueDictionary(), "http", host).Replace(oldPort, "") + "?orderGuid=" + orderGuid;

            var sender = new PaysonIntegration.Utils.Sender(payViewModel.Sender.Email);

            sender.FirstName = payViewModel.Sender.FirstName;
            sender.LastName  = payViewModel.Sender.LastName;

            var totalAmount = payViewModel.OrderItems.Sum(o => o.UnitPrice * o.Quantity * (1 + o.TaxPercentage));

            var receiver = new PaysonIntegration.Utils.Receiver(payViewModel.Receiver.Email, totalAmount);

            receiver.FirstName = payViewModel.Receiver.FirstName;
            receiver.LastName  = payViewModel.Receiver.LastName;
            receiver.SetPrimaryReceiver(true);

            var payData = new PayData(returnUrl, cancelUrl, payViewModel.Memo, sender,
                                      new List <PaysonIntegration.Utils.Receiver> {
                receiver
            });

            switch (payViewModel.GuaranteeOffered)
            {
            case GuaranteeOffered.NO:
                payData.GuaranteeOffered = PaysonIntegration.Utils.GuaranteeOffered.No;
                break;

            case GuaranteeOffered.OPTIONAL:
                payData.GuaranteeOffered = PaysonIntegration.Utils.GuaranteeOffered.Optional;
                break;

            case GuaranteeOffered.REQUIRED:
                payData.GuaranteeOffered = PaysonIntegration.Utils.GuaranteeOffered.Required;
                break;

            default:
                payData.GuaranteeOffered = null;
                break;
            }

            payData.SetCurrencyCode(payViewModel.CurrencyCode);
            var fundingConstraints = new List <FundingConstraint>();

            if (payViewModel.PaymentMethod == PaymentMethod.PaysonInvoice)
            {
                fundingConstraints.Add(FundingConstraint.Invoice);
            }
            else if (payViewModel.PaymentMethod == PaymentMethod.PaysonAll)
            {
                fundingConstraints.Add(FundingConstraint.Bank);
                fundingConstraints.Add(FundingConstraint.CreditCard);
                fundingConstraints.Add(FundingConstraint.Invoice);
            }
            else
            {
                fundingConstraints.Add(FundingConstraint.Bank);
                fundingConstraints.Add(FundingConstraint.CreditCard);
            }

            payData.SetFundingConstraints(fundingConstraints);

            payData.SetInvoiceFee(payViewModel.InvoiceFee);
            payData.SetIpnNotificationUrl(ipnNotificationUrl);
            payData.SetLocaleCode(payViewModel.LocaleCode);
            if (payViewModel.PaymentMethod == PaymentMethod.PaysonInvoice || payViewModel.PaymentMethod == PaymentMethod.PaysonAll || payViewModel.IncludeOrderDetails)
            {
                var orderItems = new List <PaysonIntegration.Utils.OrderItem>();
                foreach (var orderModel in payViewModel.OrderItems)
                {
                    var oi = new PaysonIntegration.Utils.OrderItem(orderModel.Description);
                    oi.SetOptionalParameters(orderModel.Sku, orderModel.Quantity, orderModel.UnitPrice,
                                             orderModel.TaxPercentage);
                    orderItems.Add(oi);
                }
                payData.SetOrderItems(orderItems);
            }
            payData.SetTrackingId(orderGuid);

            var api = new PaysonApi(payViewModel.UserId, payViewModel.UserKey, ApplicationId, true);


            var response = api.MakePayRequest(payData);

            if (response.Success)
            {
                var state = new PurchaseState
                {
                    UserId  = payViewModel.UserId,
                    UserKey = payViewModel.UserKey,
                    Token   = response.Token,
                    Updates = new Dictionary <DateTime, string> {
                        { DateTime.Now, "Created" }
                    },
                    OrderGuid     = orderGuid,
                    LatestStatus  = PaymentStatus.Created.ToString(),
                    ReceiverEmail = receiver.Email,
                };

                repository.SavePurchaseState(state);

                string forwardUrl =
                    string.IsNullOrWhiteSpace(payViewModel.ForwardUrl)
                        ? api.GetForwardPayUrl(response.Token)
                        : payViewModel.ForwardUrl + response.Token;

                return(Redirect(forwardUrl));
            }
            ViewBag.Errors = response.ErrorMessages;

            return(View("Index", GetDefaultPayViewModel()));
        }