예제 #1
0
def payflowlink_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404
    response_d = dict([(x[0].lower(), x[1]) for x in response_d.items()])

    paymentid = response_d.get('custid', 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=paymentid)
        processed = False

        if not payment.is_approved:  # if not already processed
            payment_update_payflowlink(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment, processed
예제 #2
0
파일: utils.py 프로젝트: goetzk/tendenci
def payflowlink_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404
    response_d = dict(map(lambda x: (x[0].lower(), x[1]), response_d.items()))

    paymentid = response_d.get('custid', 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=paymentid)
        processed = False

        if not payment.is_approved:  # if not already processed
            payment_update_payflowlink(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment, processed
예제 #3
0
def authorizenet_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=x_invoice_num)

        # Verify hash to ensure the response is securely received from authorize.net.
        # Client needs to get the Signature Key in their Authorize.Net account
        # and assign the key to the settings.py AUTHNET_SIGNATURE_KEY
        signature_key = settings.AUTHNET_SIGNATURE_KEY
        if signature_key:
            is_valid_hash = verify_hash(signature_key, response_d)
            if not is_valid_hash:
                raise Http404

        if not payment.is_approved:  # if not already processed
            payment_update_authorizenet(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #4
0
파일: utils.py 프로젝트: ZHW123/tendenci
def payflowlink_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    response_d = dict(map(lambda x: (x[0].lower(), x[1]), response_d.items()))

    paymentid = response_d.get("custid", 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    if payment.invoice.balance > 0:  # if balance==0, it means already processed
        payment_update_payflowlink(request, response_d, payment)
        payment_processing_object_updates(request, payment)
        processed = True

        # log an event
        log_payment(request, payment)

        # send payment recipients notification
        send_payment_notice(request, payment)

    return payment, processed
예제 #5
0
def pay_online(request,
               payment_id,
               template_name='payments/stripe/payonline.html'):
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=payment_id)
        form = StripeCardForm(request.POST or None)
        billing_info_form = BillingInfoForm(request.POST or None,
                                            instance=payment)
        currency = get_setting('site', 'global', 'currency')
        if not currency:
            currency = 'usd'
        if request.method == "POST":
            if form.is_valid():
                # get stripe token and make a payment immediately
                stripe.api_key = getattr(settings, 'STRIPE_SECRET_KEY', '')
                token = request.POST.get('stripe_token')

                if billing_info_form.is_valid():
                    payment = billing_info_form.save()

                # create the charge on Stripe's servers - this will charge the user's card
                params = {
                    'amount':
                    math.trunc(payment.amount * 100),  # amount in cents, again
                    'currency': currency,
                    'card': token,
                    'description': payment.description
                }

                try:
                    charge_response = stripe.Charge.create(**params)
                    # an example of response: https://api.stripe.com/v1/charges/ch_YjKFjLIItzRDv7
                    #charge_response = simplejson.loads(charge)
                except Exception as e:
                    charge_response = e.message

                # update payment status and object
                if not payment.is_approved:  # if not already processed
                    payment_update_stripe(request, charge_response, payment)
                    payment_processing_object_updates(request, payment)

                    # log an event
                    log_payment(request, payment)

                    # send payment recipients notification
                    send_payment_notice(request, payment)

                # redirect to thankyou
                return HttpResponseRedirect(
                    reverse('stripe.thank_you', args=[payment.id]))

        return render_to_response(template_name, {
            'form': form,
            'billing_info_form': billing_info_form,
            'payment': payment
        },
                                  context_instance=RequestContext(request))
예제 #6
0
파일: utils.py 프로젝트: iniForum/tendenci
def paypal_thankyou_processing(request, response_d, **kwargs):

    # validate with PayPal
    validate_type = kwargs.get('validate_type', 'PDT')

    if validate_type == 'PDT':
        success, response_d = validate_with_paypal(request, validate_type)
    else:
        success = validate_with_paypal(request, validate_type)[0]
        response_d = dict([(x[0].lower(), x[1]) for x in response_d.items()])

    if not success:
        raise Http404

    paymentid = response_d.get('invoice', 0)

    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    if payment.is_approved:  # if already processed
        return payment, processed

    # To prevent fraud, verify the following before updating the database:
    # 1) txn_id is not a duplicate to prevent someone from reusing an old,
    #    completed transaction.
    # 2) receiver_email is an email address registered in your PayPal
    #    account, to prevent the payment from being sent to a fraudulent
    #    account.
    # 3) Other transaction details, such as the item number and price,
    #    to confirm that the price has not been changed.
    if not verify_no_fraud(response_d, payment):
        return payment, processed

    with transaction.atomic():
        # verify_no_fraud() cannot be run within a transaction, so we must
        # re-retrieve payment and re-check payment.is_approved within a
        # transaction after calling verify_no_fraud() in order to prevent
        # duplicate processing of simultaneous redundant payment requests
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=paymentid)
        if not payment.is_approved:  # if not already processed
            payment_update_paypal(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

    return payment, processed
예제 #7
0
파일: views.py 프로젝트: BIGGANI/tendenci
def pay_online(request, payment_id, template_name='payments/stripe/payonline.html'):
    payment = get_object_or_404(Payment, pk=payment_id)
    form = StripeCardForm(request.POST or None)
    billing_info_form = BillingInfoForm(request.POST or None, instance=payment)
    currency = get_setting('site', 'global', 'currency')
    if not currency:
        currency = 'usd'
    if request.method == "POST":
        if form.is_valid():
            # get stripe token and make a payment immediately
            stripe.api_key = getattr(settings, 'STRIPE_SECRET_KEY', '')
            token = request.POST.get('stripe_token')

            if billing_info_form.is_valid():
                payment = billing_info_form.save()

            # create the charge on Stripe's servers - this will charge the user's card
            params = {
                       'amount': math.trunc(payment.amount * 100), # amount in cents, again
                       'currency': currency,
                       'card': token,
                       'description': payment.description
                      }

            try:
                charge_response = stripe.Charge.create(**params)
                # an example of response: https://api.stripe.com/v1/charges/ch_YjKFjLIItzRDv7
                #charge_response = simplejson.loads(charge)
            except:
                charge_response = traceback.format_exc()
                print 'error=', charge_response


            # update payment status and object
            if  payment.invoice.balance > 0:
                payment_update_stripe(request, charge_response, payment)
                payment_processing_object_updates(request, payment)

                # log an event
                log_payment(request, payment)

                # send payment recipients notification
                send_payment_notice(request, payment)

            # redirect to thankyou
            return HttpResponseRedirect(reverse('stripe.thank_you', args=[payment.id]))

    return render_to_response(template_name, {'form': form,
                                              'billing_info_form': billing_info_form,
                                              'payment': payment},
                              context_instance=RequestContext(request))
예제 #8
0
파일: utils.py 프로젝트: dkofiarmah/memba
def paypal_thankyou_processing(request, response_d, **kwargs):

    # validate with PayPal
    validate_type = kwargs.get('validate_type', 'PDT')

    if validate_type == 'PDT':
        success, response_d = validate_with_paypal(request, validate_type)
    else:
        success = validate_with_paypal(request, validate_type)[0]
        response_d = dict(
            map(lambda x: (x[0].lower(), x[1]), response_d.items()))

    if not success:
        raise Http404

    paymentid = response_d.get('invoice', 0)

    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    # To prevent the fraud, verify the following:
    # 1) txn_id is not a duplicate to prevent someone from reusing an old,
    #    completed transaction.
    # 2) receiver_email is an email address registered in your PayPal
    #    account, to prevent the payment from being sent to a fraudulent
    #    account.
    # 3) Other transaction details, such as the item number and price,
    #    to confirm that the price has not been changed.

    # if balance==0, it means already processed
    if payment.invoice.balance > 0:
        # verify before updating database
        is_valid = verify_no_fraud(response_d, payment)

        if is_valid:
            payment_update_paypal(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

    return payment, processed
예제 #9
0
파일: utils.py 프로젝트: ZHW123/tendenci
def paypal_thankyou_processing(request, response_d, **kwargs):

    # validate with PayPal
    validate_type = kwargs.get("validate_type", "PDT")

    if validate_type == "PDT":
        success, response_d = validate_with_paypal(request, validate_type)
    else:
        success = validate_with_paypal(request, validate_type)[0]
        response_d = dict(map(lambda x: (x[0].lower(), x[1]), response_d.items()))

    if not success:
        raise Http404

    paymentid = response_d.get("invoice", 0)

    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    # To prevent the fraud, verify the following:
    # 1) txn_id is not a duplicate to prevent someone from reusing an old,
    #    completed transaction.
    # 2) receiver_email is an email address registered in your PayPal
    #    account, to prevent the payment from being sent to a fraudulent
    #    account.
    # 3) Other transaction details, such as the item number and price,
    #    to confirm that the price has not been changed.

    # if balance==0, it means already processed
    if payment.invoice.balance > 0:
        # verify before updating database
        is_valid = verify_no_fraud(response_d, payment)

        if is_valid:
            payment_update_paypal(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

    return payment, processed
예제 #10
0
def authorizenet_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=x_invoice_num)

        # authenticate with md5 hash to make sure the response is securely
        # received from authorize.net.
        # client needs to set up the MD5 Hash Value in their account
        # and add this value to the local_settings.py AUTHNET_MD5_HASH_VALUE
        md5_hash = response_d.get('x_MD5_Hash', '')
        # calculate our md5_hash
        md5_hash_value = settings.AUTHNET_MD5_HASH_VALUE
        api_login_id = settings.MERCHANT_LOGIN
        t_id = response_d.get('x_trans_id', '')
        amount = response_d.get('x_amount', 0)

        s = '%s%s%s%s' % (md5_hash_value, api_login_id, t_id, amount)
        my_md5_hash = hashlib.md5(s).hexdigest()

        # don't break the payment process if md5 hash is not set up
        if md5_hash_value:
            if my_md5_hash.lower() != md5_hash.lower():
                raise Http404
        else:
            # TODO: email admin to set up MD5 hash
            pass

        if not payment.is_approved:  # if not already processed
            payment_update_authorizenet(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #11
0
파일: utils.py 프로젝트: goetzk/tendenci
def authorizenet_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=x_invoice_num)

        # authenticate with md5 hash to make sure the response is securely
        # received from authorize.net.
        # client needs to set up the MD5 Hash Value in their account
        # and add this value to the local_settings.py AUTHNET_MD5_HASH_VALUE
        md5_hash = response_d.get('x_MD5_Hash', '')
        # calculate our md5_hash
        md5_hash_value = settings.AUTHNET_MD5_HASH_VALUE
        api_login_id = settings.MERCHANT_LOGIN
        t_id = response_d.get('x_trans_id', '')
        amount = response_d.get('x_amount', 0)

        s = '%s%s%s%s' % (md5_hash_value, api_login_id, t_id, amount)
        my_md5_hash = hashlib.md5(s).hexdigest()

        # don't break the payment process if md5 hash is not set up
        if md5_hash_value:
            if my_md5_hash.lower() != md5_hash.lower():
                raise Http404
        else:
            # TODO: email admin to set up MD5 hash
            pass

        if not payment.is_approved:  # if not already processed
            payment_update_authorizenet(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #12
0
def firstdatae4_thankyou_processing(request, response_d, **kwargs):
    #from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    with transaction.atomic():
        #payment = get_object_or_404(Payment.objects.select_for_update(), pk=x_invoice_num)
        payment = Payment.objects.select_for_update().first(pk=x_invoice_num)
        if not payment:
            return None

        # authenticate with md5 hash to make sure the response is securely
        # received from firstdata.
        md5_hash = response_d.get('x_MD5_Hash', '')
        # calculate our md5_hash
        response_key = settings.FIRSTDATA_RESPONSE_KEY
        api_login_id = settings.MERCHANT_LOGIN
        t_id = response_d.get('x_trans_id', '')
        amount = response_d.get('x_amount', 0)

        s = '%s%s%s%s' % (response_key, api_login_id, t_id, amount)
        my_md5_hash = hashlib.md5(s.encode()).hexdigest()

        if settings.FIRSTDATA_USE_RELAY_RESPONSE:
            if my_md5_hash.lower() != md5_hash.lower():
                raise Http404

        if not payment.is_approved:  # if not already processed
            payment_update_firstdatae4(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #13
0
파일: utils.py 프로젝트: goetzk/tendenci
def firstdatae4_thankyou_processing(request, response_d, **kwargs):
    #from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    with transaction.atomic():
        #payment = get_object_or_404(Payment.objects.select_for_update(), pk=x_invoice_num)
        payment = Payment.objects.select_for_update().first(pk=x_invoice_num)
        if not payment:
            return None

        # authenticate with md5 hash to make sure the response is securely
        # received from firstdata.
        md5_hash = response_d.get('x_MD5_Hash', '')
        # calculate our md5_hash
        response_key = settings.FIRSTDATA_RESPONSE_KEY
        api_login_id = settings.MERCHANT_LOGIN
        t_id = response_d.get('x_trans_id', '')
        amount = response_d.get('x_amount', 0)

        s = '%s%s%s%s' % (response_key, api_login_id, t_id, amount)
        my_md5_hash = hashlib.md5(s).hexdigest()

        if settings.FIRSTDATA_USE_RELAY_RESPONSE:
            if my_md5_hash.lower() != md5_hash.lower():
                raise Http404

        if not payment.is_approved:  # if not already processed
            payment_update_firstdatae4(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #14
0
def firstdata_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    paymentid = response_d.get('paymentid', 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)

    if payment.invoice.balance > 0:  # if balance==0, it means already processed
        payment_update_firstdata(request, response_d, payment)
        payment_processing_object_updates(request, payment)

        # log an event
        log_payment(request, payment)

        # send payment recipients notification
        send_payment_notice(request, payment)

    return payment
예제 #15
0
def firstdata_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    paymentid = response_d.get('paymentid', 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=paymentid)

        if not payment.is_approved:  # if not already processed
            payment_update_firstdata(request, response_d, payment)
            payment_processing_object_updates(request, payment)

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

        return payment
예제 #16
0
파일: utils.py 프로젝트: BIGGANI/tendenci
def authorizenet_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    payment = get_object_or_404(Payment, pk=x_invoice_num)

    # authenticate with md5 hash to make sure the response is securely received from authorize.net.
    # client needs to set up the MD5 Hash Value in their account
    # and add this value to the local_settings.py AUTHNET_MD5_HASH_VALUE
    md5_hash = response_d.get('x_MD5_Hash', '')
    # calculate our md5_hash
    md5_hash_value = settings.AUTHNET_MD5_HASH_VALUE
    api_login_id = settings.MERCHANT_LOGIN
    t_id = response_d.get('x_trans_id', '')
    amount = response_d.get('x_amount', 0)

    s = '%s%s%s%s' % (md5_hash_value, api_login_id, t_id, amount)
    my_md5_hash = hashlib.md5(s).hexdigest()

    # commenting it out for now because it's causing some problem on some sites (nadr).
    #if my_md5_hash.lower() <> md5_hash.lower():
    #    raise Http404

    if payment.invoice.balance > 0:     # if balance==0, it means already processed
        payment_update_authorizenet(request, response_d, payment)
        payment_processing_object_updates(request, payment)

        # log an event
        log_payment(request, payment)

        # send payment recipients notification
        send_payment_notice(request, payment)

    return payment
예제 #17
0
파일: utils.py 프로젝트: dkofiarmah/memba
def authorizenet_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404

    x_invoice_num = response_d.get('x_invoice_num', 0)
    try:
        x_invoice_num = int(x_invoice_num)
    except:
        x_invoice_num = 0

    payment = get_object_or_404(Payment, pk=x_invoice_num)

    # authenticate with md5 hash to make sure the response is securely received from authorize.net.
    # client needs to set up the MD5 Hash Value in their account
    # and add this value to the local_settings.py AUTHNET_MD5_HASH_VALUE
    md5_hash = response_d.get('x_MD5_Hash', '')
    # calculate our md5_hash
    md5_hash_value = settings.AUTHNET_MD5_HASH_VALUE
    api_login_id = settings.MERCHANT_LOGIN
    t_id = response_d.get('x_trans_id', '')
    amount = response_d.get('x_amount', 0)

    s = '%s%s%s%s' % (md5_hash_value, api_login_id, t_id, amount)
    my_md5_hash = hashlib.md5(s).hexdigest()

    # commenting it out for now because it's causing some problem on some sites (nadr).
    #if my_md5_hash.lower() <> md5_hash.lower():
    #    raise Http404

    if payment.invoice.balance > 0:  # if balance==0, it means already processed
        payment_update_authorizenet(request, response_d, payment)
        payment_processing_object_updates(request, payment)

        # log an event
        log_payment(request, payment)

        # send payment recipients notification
        send_payment_notice(request, payment)

    return payment
예제 #18
0
def payflowlink_thankyou_processing(request, response_d, **kwargs):
    from django.shortcuts import get_object_or_404
    response_d = dict(map(lambda x: (x[0].lower(), x[1]), response_d.items()))

    paymentid = response_d.get('custid', 0)
    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    if payment.invoice.balance > 0:  # if balance==0, it means already processed
        payment_update_payflowlink(request, response_d, payment)
        payment_processing_object_updates(request, payment)
        processed = True

        # log an event
        log_payment(request, payment)

        # send payment recipients notification
        send_payment_notice(request, payment)

    return payment, processed
예제 #19
0
파일: utils.py 프로젝트: goetzk/tendenci
def paypal_thankyou_processing(request, response_d, **kwargs):

    # validate with PayPal
    validate_type = kwargs.get('validate_type', 'PDT')

    if validate_type == 'PDT':
        success, response_d = validate_with_paypal(request, validate_type)
    else:
        success = validate_with_paypal(request, validate_type)[0]
        response_d = dict(map(lambda x: (x[0].lower(), x[1]),
                              response_d.items()))

    if not success:
        raise Http404

    charset = response_d.get('charset', '')
    # make sure data is encoded in utf-8 before processing
    if charset and charset not in ('ascii', 'utf8', 'utf-8'):
        for k in response_d.keys():
            response_d[k] = response_d[k].decode(charset).encode('utf-8')

    paymentid = response_d.get('invoice', 0)

    try:
        paymentid = int(paymentid)
    except:
        paymentid = 0
    payment = get_object_or_404(Payment, pk=paymentid)
    processed = False

    if payment.is_approved:  # if already processed
        return payment, processed

    # To prevent fraud, verify the following before updating the database:
    # 1) txn_id is not a duplicate to prevent someone from reusing an old,
    #    completed transaction.
    # 2) receiver_email is an email address registered in your PayPal
    #    account, to prevent the payment from being sent to a fraudulent
    #    account.
    # 3) Other transaction details, such as the item number and price,
    #    to confirm that the price has not been changed.
    if not verify_no_fraud(response_d, payment):
        return payment, processed

    with transaction.atomic():
        # verify_no_fraud() cannot be run within a transaction, so we must
        # re-retrieve payment and re-check payment.is_approved within a
        # transaction after calling verify_no_fraud() in order to prevent
        # duplicate processing of simultaneous redundant payment requests
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=paymentid)
        if not payment.is_approved:  # if not already processed
            payment_update_paypal(request, response_d, payment)
            payment_processing_object_updates(request, payment)
            processed = True

            # log an event
            log_payment(request, payment)

            # send payment recipients notification
            send_payment_notice(request, payment)

    return payment, processed
예제 #20
0
파일: views.py 프로젝트: aprildh31/tendenci
def pay_online(request, payment_id, template_name='payments/stripe/payonline.html'):
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=payment_id)
        form = StripeCardForm(request.POST or None)
        billing_info_form = BillingInfoForm(request.POST or None, instance=payment)
        currency = get_setting('site', 'global', 'currency')
        if not currency:
            currency = 'usd'
        if request.method == "POST":
            if form.is_valid():
                # get stripe token and make a payment immediately
                stripe.api_key = getattr(settings, 'STRIPE_SECRET_KEY', '')
                token = request.POST.get('stripe_token')

            if billing_info_form.is_valid():
                payment = billing_info_form.save()

            # determine if we need to create a stripe customer (for membership auto renew)
            customer = False
            obj_user = None
            membership = None
            obj = payment.invoice.get_object()
            if obj and hasattr(obj, 'memberships'):
                membership = obj.memberships()[0]
                if membership.auto_renew and not membership.has_rp(platform='stripe'):
                    obj_user = membership.user
                else:
                    membership = None

            if obj_user:
                try:
                    # Create a Customer:
                    customer = stripe.Customer.create(
                                email=obj_user.email,
                                description="For membership auto renew",
                                source=token,
                    )
                except:
                    customer = None

            # create the charge on Stripe's servers - this will charge the user's card
            params = {
                       'amount': math.trunc(payment.amount * 100), # amount in cents, again
                       'currency': currency,
                       'description': payment.description
                      }
            if customer:
                params.update({'customer': customer.id})
            else:
                params.update({'card': token})

            try:
                charge_response = stripe.Charge.create(**params)
                # an example of response: https://api.stripe.com/v1/charges/ch_YjKFjLIItzRDv7
                #charge_response = simplejson.loads(charge)
            except stripe.error.CardError as e:
                # it's a decline
                json_body = e.json_body
                err  = json_body and json_body['error']
                code = err and err['code']
                message = err and err['message']
                charge_response = '{message} status={status}, code={code}'.format(
                            message=message, status=e.http_status, code=code)
            except Exception as e:
                charge_response = e.message

            # add a rp entry now
            if hasattr(charge_response,'paid') and charge_response.paid:
                if customer and membership:
                    kwargs = {'platform': 'stripe',
                              'customer_profile_id': customer.id,
                              }
                    membership.get_or_create_rp(request.user, **kwargs)

            # update payment status and object
            if not payment.is_approved:  # if not already processed
                payment_update_stripe(request, charge_response, payment)
                payment_processing_object_updates(request, payment)

                # log an event
                log_payment(request, payment)

                # send payment recipients notification
                send_payment_notice(request, payment)

            # redirect to thankyou
            return HttpResponseRedirect(reverse('stripe.thank_you', args=[payment.id]))

    return render_to_resp(request=request, template_name=template_name,
                              context={'form': form,
                                              'billing_info_form': billing_info_form,
                                              'STRIPE_PUBLISHABLE_KEY': settings.STRIPE_PUBLISHABLE_KEY,
                                              'payment': payment})
예제 #21
0
파일: views.py 프로젝트: seiddegu/tendenci
def pay_online(request,
               payment_id,
               guid='',
               template_name='payments/stripe/payonline.html'):
    if not getattr(settings, 'STRIPE_SECRET_KEY', ''):
        url_setup_guide = 'https://www.tendenci.com/help-files/setting-up-online-payment-processor-and-merchant-provider-on-a-tendenci-site/'
        url_setup_guide = '<a href="{0}">{0}</a>'.format(url_setup_guide)
        merchant_provider = get_setting("site", "global", "merchantaccount")
        msg_string = _(
            'ERROR: Online payment has not yet be set up or configured correctly. '
        )
        if request.user.is_superuser:
            msg_string += _(
                'Please follow the guide {0} to complete the setup process for {1}, then try again.'
            ).format(url_setup_guide, merchant_provider)
        else:
            msg_string += _(
                'Please contact the site administrator to complete the setup process.'
            )

        messages.add_message(request, messages.ERROR, _(msg_string))

        payment = get_object_or_404(Payment, pk=payment_id, guid=guid)

        return HttpResponseRedirect(
            reverse('invoice.view', args=[payment.invoice.id]))

    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(),
                                    pk=payment_id,
                                    guid=guid)
        form = StripeCardForm(request.POST or None)
        billing_info_form = BillingInfoForm(request.POST or None,
                                            instance=payment)
        currency = get_setting('site', 'global', 'currency')
        if not currency:
            currency = 'usd'
        if request.method == "POST" and form.is_valid():
            # get stripe token and make a payment immediately
            stripe.api_key = getattr(settings, 'STRIPE_SECRET_KEY', '')
            stripe.api_version = settings.STRIPE_API_VERSION
            stripe_set_app_info(stripe)
            token = request.POST.get('stripe_token')

            if billing_info_form.is_valid():
                payment = billing_info_form.save()

            # determine if we need to create a stripe customer (for membership auto renew)
            customer = False
            obj_user = None
            membership = None
            obj = payment.invoice.get_object()
            if obj and hasattr(obj, 'memberships'):
                if obj.memberships:
                    membership = obj.memberships()[0]
                    if membership.auto_renew and not membership.has_rp(
                            platform='stripe'):
                        obj_user = membership.user
                    else:
                        membership = None

            if obj_user:
                try:
                    # Create a Customer:
                    customer = stripe.Customer.create(
                        email=obj_user.email,
                        description="For membership auto renew",
                        source=token,
                    )
                except:
                    customer = None

            # create the charge on Stripe's servers - this will charge the user's card
            params = {
                'amount':
                math.trunc(payment.amount * 100),  # amount in cents, again
                'currency': currency,
                'description': payment.description
            }
            if customer:
                params.update({'customer': customer.id})
            else:
                params.update({'card': token})

            try:
                charge_response = stripe.Charge.create(**params)
                # an example of response: https://api.stripe.com/v1/charges/ch_YjKFjLIItzRDv7
                #charge_response = simplejson.loads(charge)
            except stripe.error.CardError as e:
                # it's a decline
                json_body = e.json_body
                err = json_body and json_body['error']
                code = err and err['code']
                message = err and err['message']
                charge_response = '{message} status={status}, code={code}'.format(
                    message=message, status=e.http_status, code=code)
            except Exception as e:
                charge_response = e.message

            # add a rp entry now
            if hasattr(charge_response, 'paid') and charge_response.paid:
                if customer and membership:
                    kwargs = {
                        'platform': 'stripe',
                        'customer_profile_id': customer.id,
                    }
                    membership.get_or_create_rp(request.user, **kwargs)

            # update payment status and object
            if not payment.is_approved:  # if not already processed
                payment_update_stripe(request, charge_response, payment)
                payment_processing_object_updates(request, payment)

                # log an event
                log_payment(request, payment)

                # send payment recipients notification
                send_payment_notice(request, payment)

            # redirect to thankyou
            return HttpResponseRedirect(
                reverse('stripe.thank_you', args=[payment.id, payment.guid]))

    return render_to_resp(request=request,
                          template_name=template_name,
                          context={
                              'form': form,
                              'billing_info_form': billing_info_form,
                              'STRIPE_PUBLISHABLE_KEY':
                              settings.STRIPE_PUBLISHABLE_KEY,
                              'payment': payment
                          })
예제 #22
0
파일: views.py 프로젝트: goetzk/tendenci
def pay_online(request, payment_id, template_name='payments/stripe/payonline.html'):
    with transaction.atomic():
        payment = get_object_or_404(Payment.objects.select_for_update(), pk=payment_id)
        form = StripeCardForm(request.POST or None)
        billing_info_form = BillingInfoForm(request.POST or None, instance=payment)
        currency = get_setting('site', 'global', 'currency')
        if not currency:
            currency = 'usd'
        if request.method == "POST":
            if form.is_valid():
                # get stripe token and make a payment immediately
                stripe.api_key = getattr(settings, 'STRIPE_SECRET_KEY', '')
                token = request.POST.get('stripe_token')

            if billing_info_form.is_valid():
                payment = billing_info_form.save()
                
            # determine if we need to create a stripe customer (for membership auto renew)
            customer = False
            obj_user = None
            membership = None
            obj = payment.invoice.get_object()
            if obj and hasattr(obj, 'memberships'):
                membership = obj.memberships()[0]
                if membership.auto_renew and not membership.has_rp(platform='stripe'):
                    obj_user = membership.user
                else:
                    membership = None
                    
            if obj_user:
                try:
                    # Create a Customer:
                    customer = stripe.Customer.create(
                                email=obj_user.email,
                                description="For membership auto renew",
                                source=token,
                    )
                except:
                    customer = None

            # create the charge on Stripe's servers - this will charge the user's card
            params = {
                       'amount': math.trunc(payment.amount * 100), # amount in cents, again
                       'currency': currency,
                       'description': payment.description
                      }
            if customer:
                params.update({'customer': customer.id})
            else:
                params.update({'card': token})

            try:
                charge_response = stripe.Charge.create(**params)
                # an example of response: https://api.stripe.com/v1/charges/ch_YjKFjLIItzRDv7
                #charge_response = simplejson.loads(charge)
            except stripe.error.CardError as e:
                # it's a decline
                json_body = e.json_body
                err  = json_body and json_body['error']
                code = err and err['code']
                message = err and err['message']
                charge_response = '{message} status={status}, code={code}'.format(
                            message=message, status=e.http_status, code=code)
            except Exception as e:
                charge_response = e.message
               
            # add a rp entry now 
            if hasattr(charge_response,'paid') and charge_response.paid:
                if customer and membership:
                    kwargs = {'platform': 'stripe',
                              'customer_profile_id': customer.id,
                              }
                    membership.get_or_create_rp(request.user, **kwargs)

            # update payment status and object
            if not payment.is_approved:  # if not already processed
                payment_update_stripe(request, charge_response, payment)
                payment_processing_object_updates(request, payment)

                # log an event
                log_payment(request, payment)

                # send payment recipients notification
                send_payment_notice(request, payment)

            # redirect to thankyou
            return HttpResponseRedirect(reverse('stripe.thank_you', args=[payment.id]))

    return render_to_response(template_name, {'form': form,
                                              'billing_info_form': billing_info_form,
                                              'STRIPE_PUBLISHABLE_KEY': settings.STRIPE_PUBLISHABLE_KEY,
                                              'payment': payment},
                              context_instance=RequestContext(request))