예제 #1
0
def wepay_membership_response(user):
    """
  Make a WePay API call for membership payment and return the response.
  """
    # Generate verification_key for wepay payment.
    random_string = base64.urlsafe_b64encode(os.urandom(30))
    verification_key = hashlib.sha224(random_string + user.email +
                                      user.name).hexdigest()

    user.wepay_verification = verification_key
    db.session.commit()

    # WePay Application settings
    account_id = app.config['WEPAY_ACCT_ID']
    access_token = app.config['WEPAY_ACC_TOK']
    production = app.config['WEPAY_IN_PROD']

    wepay = WePay(production, access_token)
    redirect_url = app.config['HOST_URL'] + '/verify/' + verification_key

    response = wepay.call(
        '/checkout/create', {
            'account_id': account_id,
            'amount': '20.00',
            'short_description': '1 year ACM Club Membership',
            'mode': 'regular',
            'type': 'SERVICE',
            'redirect_uri': redirect_url
        })

    return response
예제 #2
0
    def GET(self):
        wepay = WePay(IN_PRODUCTION)

        # redirect to wepay for authorization
        web.redirect(
            wepay.get_authorization_url(web.ctx.homedomain + '/callback',
                                        CLIENT_ID))
예제 #3
0
    def GET(self, query):
        wepay = WePay(IN_PRODUCTION)
        code = web.input(code='')['code']
        try:
            # try to get a token with our code
            wepay.get_token(web.ctx.homedomain + '/callback', CLIENT_ID,
                            CLIENT_SECRET, code)

            # make a new account
            create_response = wepay.call(
                '/account/create', {
                    'name': 'kitty expenses fund',
                    'description': 'all the money for my kitty'
                })

            # give the account a new picture
            wepay.call(
                '/account/modify', {
                    'account_id': create_response['account_id'],
                    'image_uri': 'http://www.placekitten.com/500/500'
                })

            # redirect to the new account
            web.redirect(create_response['account_uri'])

        except WePay.WePayError as e:
            return "Received a WePay Error: " + repr(e)
예제 #4
0
 def __init__(self):
     merchant_settings = getattr(settings, "MERCHANT_SETTINGS")
     if not merchant_settings or not merchant_settings.get("we_pay"):
         raise GatewayNotConfigured("The '%s' gateway is not correctly "
                                    "configured." % self.display_name)
     super(WePayGateway, self).__init__()
     production = not self.test_mode
     self.we_pay = WePay(production)
     self.we_pay_settings = merchant_settings["we_pay"]
예제 #5
0
 def test_silent_and_warnings(self):
     # production=False, silent=None or False -> raises WePayWarning
     self.assertRaises(WePayWarning, self.api.user.modify, foo='bar')
     # production=True or False, silent=True -> suppresses param check completely
     api = WePay(production=False, silent=True)
     self.assertRaises(WePayError, api.user.modify, foo='bar')
     # production=True, silent=None -> prints warning and will raise WePayError
     api = WePay(production=True)
     api.call = MagicMock()
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         api.user.modify(foo='bar')
         self.assertEqual(len(w), 1)
         self.assertIs(w[-1].category, WePayWarning)
     # production=True, silent=False -> raises WePayWarning
     api = WePay(production=True, silent=False)
     api.call = MagicMock()
     self.assertRaises(WePayWarning, api.user.modify, foo='bar')
예제 #6
0
def test_default_timeout_is_passed_to_requests():
    api = WePay()
    api.requests = Mock()
    api.call('/some_uri')
    eq_([call('https://wepayapi.com/v2/some_uri',
              headers={'Content-Type': 'application/json',
                       'User-Agent': 'WePay Python SDK'},
              data=None, timeout=30)],
        api.requests.post.call_args_list)
예제 #7
0
 def test_urllib_connection_error(self):
     api = WePay(production=False, use_requests=False, timeout=0.001)
     self.assertRaises(WePayConnectionError, api.call, '/app')
     try:
         api.call('/app')
     except WePayConnectionError as e:
         self.assertIsInstance(e.error, urllib.error.URLError)
         self.assertEqual(str(e), "URLError - <urlopen error timed out>")
         self.assertEqual(repr(e), "<WePayConnectionError> " + str(e))
예제 #8
0
 def test_urllib(self):
     api = WePay(production=False, use_requests=False)
     self.assertRaises(WePayError, api.call, '/app')
     try:
         api.call('/app')
     except WePayClientError as e:
         self.assertIsInstance(e.http_error, urllib.error.HTTPError)
         self.assertEqual(e.status_code, 400)
         self.assertEqual(e.error, "invalid_request")
         self.assertEqual(e.error_code, 1004)
         self.assertEqual(e.error_description, "client_id parameter is required")
         self.assertEqual(repr(e), "<WePayClientError> " + str(e))
예제 #9
0
 def test_uris_production(self):
     api = WePay()
     self.assertEqual(api.api_endpoint,
                      "https://wepayapi.com/v2")
     self.assertEqual(api.browser_uri,
                      "https://www.wepay.com")
     self.assertEqual(api.browser_js,
                      "https://www.wepay.com/min/js/wepay.v2.js")
     self.assertEqual(api.browser_iframe_js,
                      "https://www.wepay.com/min/js/iframe.wepay.js")
     self.assertEqual(api.browser_endpoint,
                      "https://www.wepay.com/v2")        
예제 #10
0
 def test_requests_missing(self):
     from wepay import utils
     has_requests = utils.HAS_REQUESTS
     utils.HAS_REQUESTS = False
     # test the warning, if requests are misiing
     self.assertRaises(WePayWarning, WePay, 
                       production=False, use_requests=True, silent=False)
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         WePay(production=False, use_requests=True)
         self.assertEqual(len(w), 1)
         self.assertIs(w[-1].category, WePayWarning)
     utils.HAS_REQUESTS = has_requests
예제 #11
0
 def test_headers(self):
     api = WePay(production=False)
     api._post = MagicMock()
     api._post.configure_mock(**{'__call__': {'result': 'fake_success'}})
     access_token, api_version = 'dummy_access_token', '2011-01-15'
     expected_headers = {
         'Content-Type': 'application/json', 
         'User-Agent': 'Python WePay SDK (third party)',
         'Authorization': 'Bearer %s' % access_token,
         'Api-Version': api_version
       }
     api.call('/user', access_token=access_token, api_version=api_version)
     api._post.assert_called_once_with(
         'https://stage.wepayapi.com/v2/user', {}, expected_headers, 30)
예제 #12
0
    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, 'That issue was not found.')
            return redirect("/")
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)
        if self.request.GET.get('paymentId'):
            import paypalrestsdk
            paypalrestsdk.configure({
                'mode': settings.MODE,
                'client_id': settings.CLIENT_ID,
                'client_secret': settings.CLIENT_SECRET
            })

            payment = paypalrestsdk.Payment.find(self.request.GET.get('paymentId'))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get('PayerID')}):
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get('checkout_id')
                    obj.save()
                    action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)

        if self.request.GET.get('checkout_id'):
            wepay = WePay(settings.WEPAY_IN_PRODUCTION, settings.WEPAY_ACCESS_TOKEN)
            wepay_data = wepay.call('/checkout/', {
                'checkout_id': self.request.GET.get('checkout_id'),
            })

            for obj in serializers.deserialize("xml", wepay_data['long_description'], ignorenonexistent=True):
                obj.object.created = datetime.datetime.now()
                obj.object.checkout_id = self.request.GET.get('checkout_id')
                obj.save()
                action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                post_to_slack(obj.object)
                if not settings.DEBUG:
                    create_comment(obj.object.issue)

        return super(IssueDetailView, self).get(request, *args, **kwargs)
예제 #13
0
    def get(self, request, *args, **kwargs):
        if self.request.GET.get('checkout_id'):
            wepay = WePay(settings.WEPAY_IN_PRODUCTION,
                          settings.WEPAY_ACCESS_TOKEN)
            wepay_data = wepay.call(
                '/checkout/', {
                    'checkout_id': self.request.GET.get('checkout_id'),
                })

            for obj in serializers.deserialize("xml",
                                               wepay_data['long_description'],
                                               ignorenonexistent=True):
                obj.object.created = datetime.datetime.now()
                obj.object.checkout_id = self.request.GET.get('checkout_id')
                obj.save()
                action.send(self.request.user,
                            verb='placed a $' + str(obj.object.price) +
                            ' bounty on ',
                            target=obj.object.issue)
                post_to_slack(obj.object)
                if not settings.DEBUG:
                    create_comment(obj.object.issue)

        return super(IssueDetailView, self).get(request, *args, **kwargs)
예제 #14
0
    p = 0.0
    while True:
        if bouncy(i):
            b+= 1  #contador de numeros bouncy

        p = (b / i)
        if p >= .99:  #hallando porcentaje deseado 99%
            print(i)  #imprimiendo porcentaje
            return(i)
        i += 1
find() #llamando funcion que encuentra porcentaje

#utilizando api de wepay
# download the Python SDK at https://github.com/wepay/Python-SDK o pipi install wepay
from wepay import WePay
wepay = WePay()
wepay = WePay(production=False,access_token='STAGE_df1684a1c7b91f0de51b72e5890891b92d34e47fb3cb48d4dbd8d2a89fa253cc')
response = wepay.call('/preapproval/create', {
	'account_id': 161624111,
	'period': 'monthly',
	'end_time': '2013-12-25',
	'amount': '19.99',
	'short_description': 'A subscription to our magazine.',
	'redirect_uri': 'http://example.com/success/',
	'auto_recur': True
})

print response

# redirect user to response['checkout_uri']
예제 #15
0
from wepay import WePay

# application settings
account_id = 1178716227
access_token = 'STAGE_91d23ae0d1b8ed89e4d5585137748aad7c0e1ff58ea725b16455af78bd3b8ca5'
production = False

# credit card id to charge
credit_card_id = 2207927703

# set production to True for live environments
wepay = WePay(production, access_token)

# charge the credit card
response = wepay.call('/checkout/create', {
	'account_id': account_id,
	'amount': '25.50',
	'short_description': 'A brand new soccer ball',
	'type': 'GOODS',
	'payment_method_id': credit_card_id, # the user's credit_card_id
	'payment_method_type': 'credit_card'
})

# display the response
print response
예제 #16
0
def create_issue_and_bounty(request):
    languages = []
    for lang in Issue.LANGUAGES:
        languages.append(lang[0])
    user = request.user

    if request.method == 'GET':
        url = request.GET.get('url')
        if url:
            helper = get_issue_helper(request, url)
            issue_data = helper.get_issue(request, url)
            if not issue_data:
                messages.error(request, 'Please provide an valid issue url')
                return redirect('/post')

            form = IssueCreateForm(
                initial={
                    'issueUrl': request.GET.get('url'),
                    'title': issue_data['title'],
                    'content': issue_data['content'] or "Added from Github"
                })
        else:
            form = IssueCreateForm()
        return render(request, 'post.html', {
            'languages': languages,
            'form': form,
        })
    if request.method == 'POST':
        url = request.POST.get('issueUrl', '')
        if not url:
            messages.error(request, 'Please provide an issue url')
            return render(request, 'post.html', {'languages': languages})
        try:
            helper = get_issue_helper(request, url)
            issue_data = helper.get_issue(request, url)
            if issue_data and "service" in issue_data:
                service = Service.objects.get(name=issue_data['service'])
                instance = Issue(number=issue_data['number'],
                                 project=issue_data['project'],
                                 user=issue_data['user'],
                                 service=service)
        except:
            return render(
                request, 'post.html', {
                    'languages':
                    languages,
                    'message':
                    'Please provide a propper issue url like \
                - https://github.com/CoderBounty/coderbounty/issues/83',
                })
        form = IssueCreateForm(request.POST, instance=instance)
        bounty_form = BountyCreateForm(request.POST)
        bounty_form_is_valid = bounty_form.is_valid()
        if form.is_valid() and bounty_form_is_valid:
            price = bounty_form.cleaned_data['price']
            if int(price) < 5:
                return render(
                    request, 'post.html', {
                        'languages': languages,
                        'message': 'Bounty must be greater than $5',
                    })
            try:
                issue = form.save()
            except:
                issue = Issue.objects.get(number=issue_data['number'],
                                          project=issue_data['project'],
                                          user=issue_data['user'],
                                          service=service)

            bounty_instance = Bounty(user=user, issue=issue, price=price)
            if int(request.user.userprofile.balance or 0) >= int(
                    request.POST.get('grand_total')):
                profile = request.user.userprofile
                profile.balance = int(request.user.userprofile.balance) - int(
                    request.POST.get('grand_total'))
                profile.save()
                bounty_instance.save()
                if not settings.DEBUG:
                    create_comment(issue)
                return redirect(issue.get_absolute_url())
            else:
                data = serializers.serialize('xml', [
                    bounty_instance,
                ])

                wepay = WePay(settings.WEPAY_IN_PRODUCTION,
                              settings.WEPAY_ACCESS_TOKEN)
                wepay_data = wepay.call(
                    '/checkout/create', {
                        'account_id':
                        settings.WEPAY_ACCOUNT_ID,
                        'amount':
                        request.POST.get('grand_total'),
                        'short_description':
                        'CoderBounty',
                        'long_description':
                        data,
                        'type':
                        'service',
                        'redirect_uri':
                        request.build_absolute_uri(issue.get_absolute_url()),
                        'currency':
                        'USD'
                    })
                if "error_code" in wepay_data:
                    messages.error(request, wepay_data['error_description'])
                    return render(request, 'post.html',
                                  {'languages': languages})

                return redirect(wepay_data['checkout_uri'])

        else:
            return render(
                request, 'post.html', {
                    'languages': languages,
                    'message': form.errors,
                    'errors': form.errors,
                    'form': form,
                    'bounty_errors': bounty_form.errors,
                })
예제 #17
0
 def setUp(self):
     self.api = WePay(production=False)
예제 #18
0
def pay():
    """Payment processor for WePay.

    We use official Python SDK to make API calls. Its source code is available at
    https://github.com/wepay/Python-SDK. Description of all WePay API endpoints and
    much more useful information is available at https://www.wepay.com/developer/reference/.

    Users can make two types of donations:
    - one time single payment (https://www.wepay.com/developer/reference/checkout)
    - recurring monthly donation (https://www.wepay.com/developer/reference/preapproval)
    """
    is_donation = request.args.get('is_donation') == "True"

    if is_donation:
        form = forms.DonationForm()
    else:
        form = forms.PaymentForm()

    if not form.validate():
        return redirect(url_for('payments.error', is_donation=is_donation))

    operation_type = 'preapproval' if form.recurring.data is True else 'checkout'

    wepay = WePay(production=current_app.config['PAYMENT_PRODUCTION'],
                  access_token=current_app.config['WEPAY_ACCESS_TOKEN'])

    params = {
        'account_id': current_app.config['WEPAY_ACCOUNT_ID'],
        'amount': float(form.amount.data),
        'redirect_uri': url_for(
            'payments.complete',
            is_donation=is_donation,
            _external=True,
            _scheme=current_app.config['PREFERRED_URL_SCHEME'],
        ),
        'mode': 'regular',
        'require_shipping': True,
    }

    # Setting callback_uri that will receive IPNs if endpoint is not local
    if not (request.headers['Host'].startswith('localhost') or request.headers['Host'].startswith('127.0.0.1')):
        # Also passing arguments that will be returned with IPNs
        if is_donation:
            params['callback_uri'] = url_for(
                '.ipn',
                _external=True,
                _scheme=current_app.config['PREFERRED_URL_SCHEME'],
                is_donation=is_donation,
                editor=form.editor.data,
                anonymous=form.anonymous.data,
                can_contact=form.can_contact.data,
            )
        else:
            params['callback_uri'] = url_for(
                '.ipn',
                _external=True,
                _scheme=current_app.config['PREFERRED_URL_SCHEME'],
                is_donation=is_donation,
                invoice_number=form.invoice_number.data,
            )

    # Setting parameters that are specific for selected type of payment
    if is_donation:
        if form.recurring.data is True:
            params['period'] = 'monthly'
            params['auto_recur'] = True
            params['short_description'] = 'Recurring donation to the MetaBrainz Foundation'
        else:
            params['type'] = 'DONATION'
            params['short_description'] = 'Donation to the MetaBrainz Foundation'
    else:
        if form.recurring.data is True:
            params['period'] = 'monthly'
            params['auto_recur'] = True
            params['short_description'] = 'Recurring payment to the MetaBrainz Foundation'
        else:
            params['type'] = 'SERVICE'
            params['short_description'] = 'Payment to the MetaBrainz Foundation'

    response = wepay.call('/%s/create' % operation_type, params)

    if 'error' in response:
        return redirect(url_for('payments.error', is_donation=is_donation))
    else:
        return redirect(response['%s_uri' % operation_type])
예제 #19
0
    def verify_and_log_wepay_checkout(cls, checkout_id, editor, anonymous,
                                      can_contact):
        logging.debug('Processing WePay checkout...')

        # Looking up updated information about the object
        wepay = WePay(production=current_app.config['PAYMENT_PRODUCTION'],
                      access_token=current_app.config['WEPAY_ACCESS_TOKEN'])
        details = wepay.call('/checkout', {'checkout_id': checkout_id})

        if 'error' in details:
            logging.warning('WePay: Error: %s', details['error_description'])
            return False

        if 'gross' not in details:
            logging.warning('WePay: The total dollar amount paid is missing')
            return False

        if details['gross'] < 0.50:
            # Tiny donation
            logging.info('WePay: Tiny donation ($%s).', details['gross'])
            return True

        if details['state'] in ['settled', 'captured']:
            # Payment has been received

            # Checking that txn_id has not been previously processed
            if cls.get_by_transaction_id(details['checkout_id']) is not None:
                logging.info('WePay: Transaction ID %s has been used before.',
                             details['checkout_id'])
                return

            new_donation = cls(
                first_name=details['payer_name'],
                last_name='',
                email=details['payer_email'],
                editor_name=editor,
                can_contact=can_contact,
                anonymous=anonymous,
                amount=details['gross'] - details['fee'],
                fee=details['fee'],
                transaction_id=checkout_id,
                payment_method=PAYMENT_METHOD_WEPAY,
            )

            if 'shipping_address' in details:
                address = details['shipping_address']
                new_donation.address_street = "%s\n%s" % (address['address1'],
                                                          address['address2'])
                new_donation.address_city = address['city']
                if 'state' in address:  # US address
                    new_donation.address_state = address['state']
                else:
                    new_donation.address_state = address['region']
                if 'zip' in address:  # US address
                    new_donation.address_postcode = address['zip']
                else:
                    new_donation.address_postcode = address['postcode']

            db.session.add(new_donation)
            db.session.commit()
            logging.info('WePay: Payment added. ID: %s.', new_donation.id)

            send_receipt(
                new_donation.email,
                new_donation.payment_date,
                new_donation.amount,
                '%s %s' % (new_donation.first_name, new_donation.last_name),
                new_donation.editor_name,
            )

        elif details['state'] in ['authorized', 'reserved']:
            # Payment is pending
            logging.info('WePay: Payment is pending. State: "%s".',
                         details['state'])
            pass

        elif details['state'] in [
                'expired', 'cancelled', 'failed', 'refunded', 'chargeback'
        ]:
            # Payment has failed
            logging.warning('WePay: Payment has failed. State: "%s".',
                            details['state'])
            pass

        else:
            # Unknown status
            logging.warning('WePay: Unknown status.')
            return False

        return True
예제 #20
0
파일: __init__.py 프로젝트: wann100/Groomer
 def setUp(self):
     self.api = WePay(silent=False)
     self.api.call = MagicMock()