예제 #1
0
파일: api.py 프로젝트: flodolo/webpay
from django import http

from rest_framework import response, viewsets

from webpay.api.base import BuyerIsLoggedIn
from webpay.base.logger import getLogger
from webpay.pay import tasks

log = getLogger('w.api')


class SimulateViewSet(viewsets.ViewSet):
    permission_classes = (BuyerIsLoggedIn,)

    def create(self, request):
        if not request.session.get('is_simulation', False):
            log.info('Request to simulate without a valid session')
            return http.HttpResponseForbidden()

        tasks.simulate_notify.delay(request.session['notes']['issuer_key'],
                                    request.session['notes']['pay_request'])

        return response.Response(status=204)
예제 #2
0
from django import forms
from django.conf import settings

from django_paranoia.forms import ParanoidForm
import jwt

from lib.solitude.constants import ACCESS_SIMULATE

from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger

from .utils import lookup_issuer, UnknownIssuer

log = getLogger('w.pay')


class NetCodeForm(ParanoidForm):
    mcc = forms.RegexField(regex='^\d{2,3}$', required=True)
    mnc = forms.RegexField(regex='^\d{2,3}$', required=True)


class VerifyForm(ParanoidForm):
    req = forms.CharField()
    # If mcc or mnc are given, we'll accept any value that conforms to the
    # format. We'll then whitelist actions on particular values.
    mcc = forms.RegexField(regex='^\d{2,3}$', required=False)
    mnc = forms.RegexField(regex='^\d{2,3}$', required=False)
    key = settings.KEY
    secret = settings.SECRET
    is_simulation = False
예제 #3
0
import functools
import json
import time

from django.conf import settings
from django.core.cache import cache
from django.http import HttpResponse
from django.shortcuts import render

from cef import log_cef as _log_cef
from tower import ugettext as _

from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger

log = getLogger('w.cef')


def invert(data):
    """
    Helper to turn a dict of constants into a choices tuple.
    """
    return [(v, k) for k, v in data.items()]


def gmtime():
    return calendar.timegm(time.gmtime())


def log_cef(msg, request, **kw):
    log_cef_meta(msg, request.META.copy(), request.path_info, **kw)
예제 #4
0
파일: forms.py 프로젝트: lissyx/webpay
from django import forms
from django.conf import settings

import jwt
from django_paranoia.forms import ParanoidForm

from mozpay.exc import InvalidJWT
from mozpay.verify import verify_jwt
from webpay.base.logger import getLogger
from webpay.pay.utils import lookup_issuer, UnknownIssuer

log = getLogger('w.services')


class SigCheckForm(ParanoidForm):
    sig_check_jwt = forms.CharField()

    def clean_sig_check_jwt(self):
        enc_jwt = self.cleaned_data['sig_check_jwt'].encode('ascii', 'ignore')
        try:
            jwt_data = jwt.decode(enc_jwt, verify=False)
        except jwt.DecodeError, exc:
            log.info(
                'caught sig_check exc: {0.__class__.__name__}: {0}'.format(
                    exc))
            raise forms.ValidationError('INVALID_JWT_OR_UNKNOWN_ISSUER')

        try:
            secret, active_product = lookup_issuer(jwt_data.get('iss', ''))
        except UnknownIssuer, exc:
            log.info(
예제 #5
0
파일: views.py 프로젝트: v1ka5/webpay
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from django.utils import translation

from curling.lib import HttpClientError

from lib.marketplace.api import client as marketplace
from lib.solitude.api import client as solitude
from webpay.base.decorators import json_view
from webpay.base.dev_messages import legend
from webpay.base.logger import getLogger
from webpay.base.utils import log_cef_meta

from .forms import ErrorLegendForm, SigCheckForm

log = getLogger("z.services")


def monitor(request):
    content = {}
    all_good = True

    # Check that we can talk to the marketplace.
    msg = "ok"
    try:
        perms = marketplace.api.account.permissions.mine.get()
    except HttpClientError, err:
        all_good = False
        msg = "Server error: status %s, content: %s" % (err.response.status_code, err.response.content or "empty")
    else:
        if not perms["permissions"].get("webpay", False):
예제 #6
0
파일: persona.py 프로젝트: kyoshino/webpay
from os.path import abspath
from time import time, sleep

from django import http
from django.conf import settings
from django.views.decorators.csrf import csrf_exempt

from webpay.base.decorators import json_view
from webpay.base.logger import getLogger

log = getLogger("w.pay")

# When email addressess are prefixed with these values they will trigger login
# behavior.
OK_USER = "******"
TIMEOUT_USER = "******"
FAILED_LOGIN = "******"
ERROR_LOGIN = "******"


def fake_include(request):
    """Serve up stubbyid.js for testing."""
    if not settings.DEV or not settings.TEST_PIN_UI:
        return http.HttpResponseForbidden()

    with open(abspath("webpay/testing/stubbyid.js")) as fh:
        stub_js = fh.read()
    return http.HttpResponse(stub_js, content_type="text/javascript")


@csrf_exempt
예제 #7
0
from django.views.decorators.debug import sensitive_post_parameters

from tower import ugettext as _

from lib.solitude.api import client
from lib.solitude.exceptions import ResourceModified
from webpay.auth.decorators import enforce_sequence, user_verified
from webpay.auth.utils import (get_user, set_user_has_confirmed_pin,
                               set_user_has_pin)
from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger
from webpay.base.utils import system_error
from webpay.pay import get_wait_url
from . import forms

log = getLogger('w.pin')


@enforce_sequence
@sensitive_post_parameters('pin')
def create(request):
    form = forms.CreatePinForm()
    if request.method == 'POST':
        form = forms.CreatePinForm(uuid=get_user(request), data=request.POST)
        if form.is_valid():
            if getattr(form, 'buyer_exists', False):
                try:
                    res = client.change_pin(form.uuid,
                                            form.cleaned_data['pin'],
                                            etag=form.buyer_etag)
                except ResourceModified:
예제 #8
0
from django import forms
from django.conf import settings

import jwt
from django_paranoia.forms import ParanoidForm

from mozpay.exc import InvalidJWT
from mozpay.verify import verify_jwt
from webpay.base.logger import getLogger
from webpay.pay.utils import lookup_issuer, UnknownIssuer

log = getLogger('w.services')


class SigCheckForm(ParanoidForm):
    sig_check_jwt = forms.CharField()

    def clean_sig_check_jwt(self):
        enc_jwt = self.cleaned_data['sig_check_jwt'].encode('ascii', 'ignore')
        try:
            jwt_data = jwt.decode(enc_jwt, verify=False)
        except jwt.DecodeError, exc:
            log.info('caught sig_check exc: {0.__class__.__name__}: {0}'
                     .format(exc))
            raise forms.ValidationError('INVALID_JWT_OR_UNKNOWN_ISSUER')

        try:
            secret, active_product = lookup_issuer(jwt_data.get('iss', ''))
        except UnknownIssuer, exc:
            log.info('caught sig_check exc: {0.__class__.__name__}: {0}'
                     .format(exc))
예제 #9
0
파일: utils.py 프로젝트: v1ka5/webpay
import json

from curling.lib import API
from slumber.exceptions import HttpClientError

from lib.solitude.errors import ERROR_STRINGS
from solitude.exceptions import ResourceNotModified
from webpay.base.logger import getLogger, get_transaction_id

log = getLogger('lib.utils')


def add_transaction_id(slumber, headers=None, **kwargs):
    headers['Transaction-Id'] = get_transaction_id()


class SlumberWrapper(object):
    """
    A wrapper around the Slumber API.
    """

    def __init__(self, url, oauth):
        self.slumber = API(url)
        self.slumber.activate_oauth(oauth.get('key'), oauth.get('secret'))
        self.slumber._add_callback({'method': add_transaction_id})
        self.api = self.slumber.api.v1

    def parse_res(self, res):
        if res == '':
            return {}
        if isinstance(res, (str, unicode)):
예제 #10
0
파일: api.py 프로젝트: Witia1/webpay
from django import http
from django.core.exceptions import ObjectDoesNotExist

from rest_framework import response, serializers, viewsets

from lib.solitude.api import client
from lib.solitude.constants import PROVIDERS_INVERTED

from webpay.base.logger import getLogger
from webpay.pay.views import configure_transaction, process_pay_req, simulate

from .base import BuyerIsLoggedIn

log = getLogger("w.api")


class TransactionSerializer(serializers.Serializer):
    provider = serializers.CharField()
    pay_url = serializers.CharField()

    def __init__(self, data):
        if "provider" in data and data["provider"] in PROVIDERS_INVERTED:
            data["provider"] = PROVIDERS_INVERTED[data["provider"]]
        super(TransactionSerializer, self).__init__(data)


class PayViewSet(viewsets.ViewSet):
    permission_classes = (BuyerIsLoggedIn,)

    def create(self, request):
        res = process_pay_req(request, data=request.DATA)
예제 #11
0
import urlparse
from django.conf import settings
from django.shortcuts import render

from django_paranoia.decorators import require_GET
from mozpay.verify import InvalidJWT, _get_issuer, verify_sig
from webpay.auth.utils import set_user
from webpay.base.helpers import fxa_auth_info
from webpay.base.logger import getLogger
log = getLogger('w.spa')


@require_GET
def index(request, view_name=None, start_view=None):
    """Page that serves the static Single Page App (Spartacus)."""
    ctx = {}
    ctx['fxa_state'], ctx['fxa_auth_url'] = fxa_auth_info(request)
    jwt = request.GET.get('req')

    if jwt:
        ctx['mkt_user'] = False

    # If this is a Marketplace-issued JWT, verify its signature and skip login
    # for the purchaser named in it.
    if jwt and _get_issuer(jwt) == settings.KEY:
        try:
            data = verify_sig(jwt,
                              settings.SECRET,
                              expected_aud=settings.DOMAIN)
            data = data['request'].get('productData', '')
        except InvalidJWT, exc:
예제 #12
0
from django import http

from rest_framework import response, viewsets

from webpay.api.base import BuyerIsLoggedIn
from webpay.base.logger import getLogger
from webpay.pay import tasks

log = getLogger('w.api')


class SimulateViewSet(viewsets.ViewSet):
    permission_classes = (BuyerIsLoggedIn, )

    def create(self, request):
        if not request.session.get('is_simulation', False):
            log.info('Request to simulate without a valid session')
            return http.HttpResponseForbidden()

        tasks.simulate_notify.delay(request.session['notes']['issuer_key'],
                                    request.session['notes']['pay_request'])

        return response.Response(status=204)
예제 #13
0
파일: api.py 프로젝트: tempbottle/webpay
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.utils.decorators import method_decorator

from cache_nuggets.lib import memoize
from requests.exceptions import ConnectionError

from constants import COUNTRIES
from ..utils import SlumberWrapper

from lib.solitude.constants import PROVIDER_BANGO, PROVIDERS_INVERTED

from webpay.base.logger import getLogger

log = getLogger("w.marketplace")

NUMBER_ATTEMPTS = 5


class UnknownPricePoint(Exception):
    pass


class ConnectionFailed(ConnectionError):
    pass


class MarketplaceAPI(SlumberWrapper):
    errors = {}

    @method_decorator(memoize("marketplace:api:get_price"))
예제 #14
0
import json
import sys
import traceback
import urlparse

from django.conf import settings
from django.utils.cache import patch_vary_headers
from django.utils.translation.trans_real import parse_accept_lang_header

import tower
from csp.middleware import CSPMiddleware as BaseCSPMiddleware

from webpay.base.logger import getLogger
from webpay.base.utils import log_cef

log = getLogger('w.middleware')


class LogJSONerror:
    """
    If the exception has JSON content, log the JSON message.
    This is intended to catch and log Solitude error messages
    such as form errors for 400 errors.
    """
    def process_exception(self, request, exception):
        etype = type(exception)
        if hasattr(etype, '__name__'):
            etype = etype.__name__
        if hasattr(exception, 'content'):
            try:
                log.error('%s: %s: JSON: %s'
예제 #15
0
파일: views.py 프로젝트: hudikwebb/webpay
from django.shortcuts import render
from django.views.decorators.http import require_POST

from curling.lib import HttpClientError
from django_browserid import get_audience as get_aud_from_request, verify as verify_assertion
from django_browserid.forms import BrowserIDForm
from session_csrf import anonymous_csrf_exempt

from lib.marketplace.api import client as mkt_client
from webpay.base.decorators import json_view
from webpay.base.logger import getLogger
from webpay.pay import tasks as pay_tasks
from webpay.pin.utils import check_pin_status
from .utils import get_uuid, set_user

log = getLogger("w.auth")


@require_POST
def reset_user(request):
    """
    Reset the logged in Persona user.

    This is not meant as a full logout. It's meant to compliment
    navigator.id.logout() so that both Webpay and Persona think the user
    is logged out.
    """
    if "logged_in_user" in request.session:
        log.info("Resetting Persona user %s" % request.session["logged_in_user"])
        del request.session["logged_in_user"]
    if "mkt_permissions" in request.session:
예제 #16
0
파일: views.py 프로젝트: Joergen/webpay
from django.core.urlresolvers import reverse
from django.http import HttpResponseForbidden, HttpResponseNotFound, HttpResponse
from django.shortcuts import render

from django_paranoia.decorators import require_GET

from lib.solitude.api import client, ProviderHelper
from lib.solitude.constants import PROVIDERS_INVERTED, STATUS_COMPLETED
from webpay.base import dev_messages as msg
from webpay.base.decorators import json_view
from webpay.base.helpers import fxa_auth_info
from webpay.base.logger import getLogger
from webpay.base.utils import log_cef, system_error
from webpay.pay import tasks

log = getLogger("w.provider")
NoticeClasses = {}


@require_GET
def wait_to_finish(request, provider_name):
    """
    After the payment provider finishes the pay flow, wait for completion.

    The provider redirects here so the UI can poll Solitude until the
    transaction is complete.
    """
    helper = ProviderHelper(provider_name)
    trans_uuid = helper.provider.transaction_from_notice(request.GET)
    if not trans_uuid:
        # This could happen if someone is tampering with the URL or if
예제 #17
0
import json
import sys
import traceback
import urlparse

from django.conf import settings
from django.utils.cache import patch_vary_headers
from django.utils.translation.trans_real import parse_accept_lang_header

import tower
from csp.middleware import CSPMiddleware as BaseCSPMiddleware

from webpay.base.logger import getLogger
from webpay.base.utils import log_cef

log = getLogger("w.middleware")


class LogJSONerror:
    """
    If the exception has JSON content, log the JSON message.
    This is intended to catch and log Solitude error messages
    such as form errors for 400 errors.
    """

    def process_exception(self, request, exception):
        etype = type(exception)
        if hasattr(etype, "__name__"):
            etype = etype.__name__
        if hasattr(exception, "content"):
            try:
예제 #18
0
파일: views.py 프로젝트: lissyx/webpay
from django.http import HttpResponse
from django.shortcuts import render

from django_paranoia.decorators import require_GET

from lib.solitude.api import ProviderHelper
from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger
from webpay.base.utils import system_error
from webpay.pay import tasks

log = getLogger('w.provider')
NoticeClasses = {}


@require_GET
def success(request, provider_name):
    provider = ProviderHelper(provider_name)
    if provider.name != 'reference':
        raise NotImplementedError(
            'only the reference provider is implemented so far')

    try:
        transaction_id = provider.prepare_notice(request)
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    tasks.payment_notify.delay(transaction_id)
    return render(request, 'provider/success.html')

예제 #19
0
파일: views.py 프로젝트: Nurtas/webpay
import urlparse
from django import http
from django.conf import settings
from django.shortcuts import render

from django_paranoia.decorators import require_GET
from mozpay.verify import InvalidJWT, _get_issuer, verify_sig
from webpay.auth.utils import set_user
from webpay.base.helpers import fxa_auth_info
from webpay.base.logger import getLogger
log = getLogger('w.spa')


@require_GET
def index(request, view_name=None):
    """Page that serves the static Single Page App (Spartacus)."""
    if not settings.SPA_ENABLE:
        return http.HttpResponseForbidden()
    ctx = {}
    if settings.USE_FXA:
        ctx['fxa_state'], ctx['fxa_auth_url'] = fxa_auth_info(request)
    jwt = request.GET.get('req')
    # If this is a Marketplace-issued JWT, verify its signature and skip login
    # for the purchaser named in it.
    if jwt and _get_issuer(jwt) == settings.KEY:
        try:
            data = verify_sig(jwt, settings.SECRET)
            data = data['request'].get('productData', '')
        except InvalidJWT:
            pass
        else:
예제 #20
0
import json
import sys
import traceback
import urlparse

from django.conf import settings
from django.utils.cache import patch_vary_headers
from django.utils.translation.trans_real import parse_accept_lang_header

import tower
from csp.middleware import CSPMiddleware as BaseCSPMiddleware

from webpay.base.logger import getLogger
from webpay.base.utils import log_cef

log = getLogger('w.middleware')


class LogJSONerror:
    """
    If the exception has JSON content, log the JSON message.
    This is intended to catch and log Solitude error messages
    such as form errors for 400 errors.
    """
    def process_exception(self, request, exception):
        etype = type(exception)
        if hasattr(etype, '__name__'):
            etype = etype.__name__
        if hasattr(exception, 'content'):
            try:
                log.error('%s: %s: JSON: %s'
예제 #21
0
import base64

from webpay.base.logger import getLogger

log = getLogger('w.bango')


class NoHeader(Exception):
    pass


class WrongHeader(Exception):
    pass


def basic(request):
    header = request.META.get('HTTP_AUTHORIZATION', '')
    if not header:
        log.info('No Authorization header')
        raise NoHeader

    try:
        auth_type, data = header.split()
    except ValueError:
        log.info("Invalid header, can't split: {0}".format(header))
        raise WrongHeader

    if auth_type.lower() != 'basic':
        log.info('Authorization type {0} not supported'.format(auth_type))
        raise WrongHeader
예제 #22
0
파일: views.py 프로젝트: tempbottle/webpay
from django.views.decorators.http import require_POST
from django.utils import translation

from curling.lib import HttpClientError, HttpServerError
from rest_framework import viewsets

from lib.marketplace.api import client as marketplace
from lib.solitude.api import client as solitude
from webpay.base.decorators import json_view
from webpay.base.dev_messages import legend
from webpay.base.logger import getLogger
from webpay.base.utils import log_cef_meta

from .forms import ErrorLegendForm, SigCheckForm

log = getLogger('z.services')


def monitor(request):
    content = {}
    all_good = True

    # Check that we can talk to the marketplace.
    msg = 'ok'
    try:
        perms = marketplace.api.account.permissions.mine.get()
    except (HttpServerError, HttpClientError), err:
        all_good = False
        msg = ('Server error: status {0}, content: {1}'.format(
            err.response.status_code, err.response.content or 'empty')
               if err.response else 'Server error: no response')
예제 #23
0
파일: views.py 프로젝트: hudikwebb/webpay
from webpay.base.decorators import json_view
from webpay.base.logger import getLogger
from webpay.base.utils import app_error, custom_error, system_error
from webpay.pin.forms import VerifyPinForm
from webpay.pin.utils import check_pin_status

from lib.marketplace.api import client as marketplace, UnknownPricePoint
from lib.solitude import constants
from lib.solitude.api import client as solitude
from lib.solitude.exceptions import ResourceModified

from . import tasks
from .forms import VerifyForm
from .utils import clear_messages, trans_id, verify_urls

log = getLogger('w.pay')


def process_pay_req(request, data=None):
    data = request.GET if data is None else data
    form = VerifyForm(data)
    if not form.is_valid():
        codes = []
        for erlist in form.errors.values():
            codes.extend(erlist)
        if len(codes) > 1:
            # This will probably break something, like maybe paymentFailed().
            log.error('multiple error codes: {codes}'.format(codes=codes))
        codes = ', '.join(codes)
        return app_error(request, code=codes)
예제 #24
0
파일: views.py 프로젝트: Kodextor/webpay
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from django.utils import translation

from curling.lib import HttpClientError, HttpServerError

from lib.marketplace.api import client as marketplace
from lib.solitude.api import client as solitude
from webpay.base.decorators import json_view
from webpay.base.dev_messages import legend
from webpay.base.logger import getLogger
from webpay.base.utils import log_cef_meta

from .forms import ErrorLegendForm, SigCheckForm

log = getLogger('z.services')


def monitor(request):
    content = {}
    all_good = True

    # Check that we can talk to the marketplace.
    msg = 'ok'
    try:
        perms = marketplace.api.account.permissions.mine.get()
    except (HttpServerError, HttpClientError), err:
        all_good = False
        msg = ('Server error: status %s, content: %s' %
               (err.response.status_code, err.response.content or 'empty'))
    else:
예제 #25
0
import functools

from django import http
from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.core.urlresolvers import reverse

from webpay.base.logger import getLogger
from webpay.base.utils import log_cef

log = getLogger('w.auth')

flow = {
    'standard': ['create', 'confirm', 'verify', 'reset_start'],
    'locked': ['is_locked', 'was_locked'],
    'reset': ['reset_new_pin', 'reset_confirm', 'reset_cancel'],
}


def log_redirect(request, step, dest):
    msg = 'Buyer was attempting %s redirecting to: %s' % (step, dest)
    log.info('enforce_sequence: %s' % msg)
    log_cef(msg, request, severity=7)


def user_verified(f):
    @functools.wraps(f)
    def wrapper(request, *args, **kw):
        if not request.session.get('uuid'):
            log_cef('No UUID in session, not verified', request, severity=7)
            raise PermissionDenied
예제 #26
0
from django.conf import settings
from django.http import HttpResponse, HttpResponseForbidden
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt

from django_paranoia.decorators import require_GET, require_POST
from slumber.exceptions import HttpClientError
from tower import ugettext as _

from lib.solitude.api import client
from webpay.bango.auth import basic, NoHeader, WrongHeader
from webpay.base.logger import getLogger
from webpay.base.utils import _error
from webpay.pay import tasks

log = getLogger("w.bango")


class HttpResponseNotAuthenticated(HttpResponse):
    status_code = 401

    def __init__(self, *args):
        super(HttpResponseNotAuthenticated, self).__init__(*args)
        self["WWW-Authenticate"] = 'Basic realm="{0}"'.format(settings.DOMAIN)


def _record(request):
    """
    Records the request into solitude. If something went wrong it will
    return False.
    """
예제 #27
0
import hashlib
import hmac
import re

from django.conf import settings
from django.core.exceptions import PermissionDenied

from lib.solitude.api import client
from webpay.base.logger import getLogger

log  = getLogger('w.auth')


def check_whitelist(email):
    whitelist = settings.USER_WHITELIST

    if not whitelist:
        return True

    for email_re in whitelist:
        if re.match(email_re, email):
            return True

    return False


def get_uuid(email):
    """
    Given an email returns an email token for this site. This will be
    consistent for each email for this site and can be used as the uuid in
    solitude. The email is protected by HMAC for privacy purposes.
예제 #28
0
import json

from curling.lib import API
from slumber.exceptions import HttpClientError

from solitude.exceptions import ResourceModified, ResourceNotModified
from webpay.base.logger import getLogger, get_transaction_id

log = getLogger('lib.utils')


def add_transaction_id(slumber, headers=None, **kwargs):
    headers['Transaction-Id'] = get_transaction_id()


class SlumberWrapper(object):
    """
    A wrapper around the Slumber API.
    """
    def __init__(self, url, oauth):
        self.slumber = API(url)
        self.slumber.activate_oauth(oauth.get('key'), oauth.get('secret'))
        self.slumber._add_callback({'method': add_transaction_id})
        self.api = self.slumber.api.v1

    def parse_res(self, res):
        if res == '':
            return {}
        if isinstance(res, (str, unicode)):
            try:
                return json.loads(res)
예제 #29
0
파일: views.py 프로젝트: Kodextor/webpay
from django.views.decorators.debug import sensitive_post_parameters

from tower import ugettext as _

from lib.solitude.api import client
from lib.solitude.exceptions import ResourceModified
from webpay.auth.decorators import enforce_sequence, user_verified
from webpay.auth.utils import (get_user, set_user_has_confirmed_pin,
                               set_user_has_pin)
from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger
from webpay.base.utils import system_error
from webpay.pay import get_payment_url
from . import forms

log = getLogger('w.pin')


@enforce_sequence
@sensitive_post_parameters('pin')
def create(request):
    form = forms.CreatePinForm()
    if request.method == 'POST':
        form = forms.CreatePinForm(uuid=get_user(request), data=request.POST)
        if form.is_valid():
            if getattr(form, 'buyer_exists', False):
                try:
                    res = client.change_pin(form.uuid,
                                            form.cleaned_data['pin'],
                                            etag=form.buyer_etag)
                except ResourceModified:
예제 #30
0
from django.core.urlresolvers import reverse
from django.http import (HttpResponseForbidden, HttpResponseNotFound,
                         HttpResponse)
from django.shortcuts import render

from django_paranoia.decorators import require_GET

from lib.solitude.api import client, ProviderHelper
from lib.solitude.constants import PROVIDERS_INVERTED, STATUS_COMPLETED
from webpay.base import dev_messages as msg
from webpay.base.decorators import json_view
from webpay.base.logger import getLogger
from webpay.base.utils import log_cef, system_error
from webpay.pay import tasks

log = getLogger('w.provider')
NoticeClasses = {}


@require_GET
def wait_to_finish(request, provider_name):
    """
    After the payment provider finishes the pay flow, wait for completion.

    The provider redirects here so the UI can poll Solitude until the
    transaction is complete.
    """
    helper = ProviderHelper(provider_name)
    trans_uuid = helper.provider.transaction_from_notice(request.GET)
    if not trans_uuid:
        # This could happen if someone is tampering with the URL or if
예제 #31
0
from django.conf import settings
from django.http import HttpResponse, HttpResponseForbidden
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt

from django_paranoia.decorators import require_GET, require_POST
from slumber.exceptions import HttpClientError

from lib.solitude.api import client
from webpay.bango.auth import basic, NoHeader, WrongHeader
from webpay.base import dev_messages as msg
from webpay.base.logger import getLogger
from webpay.base.utils import system_error
from webpay.pay import tasks

log = getLogger('w.bango')
RECORDED_OK = 'RECORDED_OK'


class HttpResponseNotAuthenticated(HttpResponse):
    status_code = 401

    def __init__(self, *args):
        super(HttpResponseNotAuthenticated, self).__init__(*args)
        self['WWW-Authenticate'] = 'Basic realm="{0}"'.format(settings.DOMAIN)


def _record(request):
    """
    Records the request into solitude.
예제 #32
0
파일: utils.py 프로젝트: wraithan/webpay
import json

from curling.lib import API
from slumber.exceptions import HttpClientError

from solitude.exceptions import ResourceModified, ResourceNotModified
from webpay.base.logger import getLogger, get_transaction_id

log = getLogger("lib.utils")


def add_transaction_id(slumber, headers=None, **kwargs):
    headers["Transaction-Id"] = get_transaction_id()


class SlumberWrapper(object):
    """
    A wrapper around the Slumber API.
    """

    def __init__(self, url, oauth):
        self.slumber = API(url)
        self.slumber.activate_oauth(oauth.get("key"), oauth.get("secret"))
        self.slumber._add_callback({"method": add_transaction_id})
        self.api = self.slumber.api.v1

    def parse_res(self, res):
        if res == "":
            return {}
        if isinstance(res, (str, unicode)):
            return json.loads(res)