Пример #1
0
def handle_user_signed_up(sender, **kwargs):
    log(
        user=kwargs.get("user"),
        action="USER_SIGNED_UP",
        extra={}
    )
    customers.create(kwargs.get("user"))
Пример #2
0
def create_account(sender, **kwargs):
    user = kwargs["instance"]
    if kwargs["created"]:
        account = Account(user=user)
        account.save()

        # stripe customer
        create(user, charge_immediately=False)
Пример #3
0
    def post(self, request, campaign_id, *args, **kwargs):
        # Validate request and campaign status
        try:
            campaign = Campaign.objects.get(id=campaign_id)
        except Campaign.DoesNotExist:
            return HttpResponseBadRequest("Campaign with ID {campaign_id} does not exist.".format(campaign_id=campaign_id))
        else:
            if not campaign.open():
                return HttpResponseBadRequest("This campaign is no longer accepting investments.")
        form = PaymentChargeForm(request.POST, campaign=campaign)
        if not form.is_valid():
            return HttpResponseBadRequest(unicode(form.errors))
        d = form.cleaned_data

        # Get card and customer
        card = d['card']
        customer = customers.get_customer_for_user(request.user)
        if not customer:
            customer = customers.create(request.user, card=card, plan=None, charge_immediately=False)

        # Create charge
        num_shares = d['num_shares']
        amount = decimal.Decimal(campaign.total(num_shares))
        try:
            charge = charges.create(amount=amount, customer=customer.stripe_id)
        except CardError as e:
            return HttpResponseBadRequest(e.message)
        Investment.objects.create(charge=charge, campaign=campaign, num_shares=num_shares)
        return HttpResponse(status=205)
Пример #4
0
 def create_customer(self, user, token):
     return customers.create(
         user,
         card=token,
         plan=None,
         charge_immediately=False
     )
Пример #5
0
def RegisterView(request):
    msg = ''
    email = ''
    password = ''
    plan = ''
    if request.POST:
        email = request.POST.get('email')
        password = request.POST.get('password')
        plan = request.POST.get('plan', settings.PINAX_STRIPE_DEFAULT_PLAN)
        user = User.objects.filter(email=email).first()
        if user is not None:
            msg="email_exists"
        else:
            user = User()
            user.username = email
            user.is_active = False
            user.email = email
            user.password = password
            user.set_password(password)
            user.save()

            site_name = get_current_site(request)
            # todo: change hard code subject
            subject = 'Activate account'

            # generate message
            # print(urlsafe_base64_encode(force_bytes(user.pk)))
            message = render_to_string('app/account_activation_email.html', {
                'user': user,
                'domain': site_name.domain,
                'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode("utf-8"),
                'token': account_activation_token.make_token(user),
            })
            msg = "register_success"
            # send activation link to the user
            user.email_user(subject, message)
            
            from pinax.stripe.actions import customers
            customers.create(user=user, plan=plan)
            return render(request, 'v2/registration/register_done.html', {
                'msg': msg, 'email': email, 'password': password})
            
    plans = get_main_plan()
    
    return render(request, 'v2/registration/register.html', {
    'msg': msg, 'email': email, 'password': password,
    'plan': plan, 'plans': plans})
Пример #6
0
def signup(request):
    # TODO Rewrite this to generic View.
    if request.method == 'POST':
        form = SignupForm(request.POST)
        if form.is_valid():
            form.save()
            username = form.cleaned_data.get('username')
            raw_password = form.cleaned_data.get('password1')
            user = authenticate(username=username, password=raw_password)

            # Creating Stripe customer id.
            customers.create(user=user)
            login(request, user)
            return redirect('index')
    else:
        form = SignupForm()
    return render(request, 'registration/signup.html', {'form': form})
Пример #7
0
    def post(self, request, campaign_id, *args, **kwargs):
        # Validate request and campaign status
        try:
            campaign = Campaign.objects.get(id=campaign_id)
        except Campaign.DoesNotExist:
            return Response(
                "Campaign with ID {campaign_id} does not exist.".format(
                    campaign_id=campaign_id),
                status=status.HTTP_400_BAD_REQUEST,
            )
        else:
            if not campaign.open():
                return Response(
                    "This campaign is no longer accepting investments.",
                    status=status.HTTP_400_BAD_REQUEST,
                )
        form = PaymentChargeForm(request.data, campaign=campaign)
        if not form.is_valid():
            return Response(str(form.errors),
                            status=status.HTTP_400_BAD_REQUEST)
        d = form.cleaned_data

        # Get card and customer
        card = d["card"]
        customer = customers.get_customer_for_user(request.user)
        if not customer:
            customer = customers.create(request.user,
                                        card=card,
                                        plan=None,
                                        charge_immediately=False)
            card = Card.objects.get(customer=customer)
        else:
            # Check if we have the card the user is using
            # and if not, create it
            card_fingerprint = stripe.Token.retrieve(
                card)["card"]["fingerprint"]
            cards_with_fingerprint = Card.objects.filter(
                customer=customer, fingerprint=card_fingerprint)
            if cards_with_fingerprint.exists():
                card = cards_with_fingerprint[0]
            else:
                card = sources.create_card(customer=customer, token=card)

        # Create charge
        num_shares = d["num_shares"]
        amount = decimal.Decimal(campaign.total(num_shares))
        try:
            charge = charges.create(amount=amount,
                                    customer=customer.stripe_id,
                                    source=card)
        except stripe.CardError as e:
            return Response(e.message, status=status.HTTP_400_BAD_REQUEST)
        Investment.objects.create(charge=charge,
                                  campaign=campaign,
                                  num_shares=num_shares)
        return Response(status=status.HTTP_205_RESET_CONTENT)
Пример #8
0
    def post(self, request):

        serializer = self.serializer_class(data=request.data)

        if serializer.is_valid():

            # Get or create the customer
            try:
                customer = Customer.objects.get(user=request.user)
            except Customer.DoesNotExist:
                customer = customers.create(user=request.user)

            if not customers.can_charge(customer):

                if serializer.data["card_number"]:
                    try:
                        token = stripe_token.create(
                            card={
                                "number": serializer.data["card_number"],
                                "exp_month": serializer.data["card_exp_month"],
                                "exp_year": serializer.data["card_exp_year"],
                                "cvc": serializer.data["card_cvc"]
                            })
                    except stripe.error.CardError as e:
                        data = {
                            "non_field_errors":
                            [e.json_body["error"]["message"]]
                        }
                        return Response(data,
                                        status=status.HTTP_400_BAD_REQUEST)

                    try:
                        sources.create_card(customer, token)
                    except stripe.error.CardError as e:
                        data = {
                            "non_field_errors":
                            [e.json_body["error"]["message"]]
                        }
                        return Response(data,
                                        status=status.HTTP_400_BAD_REQUEST)

            try:
                subscriptions.create(customer=customer,
                                     plan=serializer.data["plan_id"])
            except stripe.error.InvalidRequestError as e:
                data = {"non_field_errors": [e.json_body["error"]["message"]]}
                return Response(data, status=status.HTTP_400_BAD_REQUEST)

            subscription = SubscriptionUpdateSerializer(
                data={"plan_id": serializer.data["plan_id"]})
            subscription.is_valid()

            return Response(subscription.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Пример #9
0
def process_charge(request):
    if request.is_ajax():
        card_dict = json.loads(request.POST.get('token'))
        token = card_dict['id']
        # Charge the user's card:
        customer = Customer.objects.filter(user_id=request.user).first()
        if customer == None:
            customer = customers.create(user=request.user)
        plan = Plan.objects.get(stripe_id=request.POST['plan'])
        try:
            subs = subscriptions.create(customer=customer,
                                        plan=plan.stripe_id,
                                        token=token)
            valid = subscriptions.is_valid(subs)
        except Exception as e:
            return JsonResponse({'valid': False, 'message': e.message})
    return JsonResponse({'valid': valid})
Пример #10
0
    def post(self, request, campaign_id, *args, **kwargs):
        # Validate request and campaign status
        try:
            campaign = Campaign.objects.get(id=campaign_id)
        except Campaign.DoesNotExist:
            return Response(
                "Campaign with ID {campaign_id} does not exist.".format(campaign_id=campaign_id),
                status=status.HTTP_400_BAD_REQUEST
            )
        else:
            if not campaign.open():
                return Response(
                    "This campaign is no longer accepting investments.",
                    status=status.HTTP_400_BAD_REQUEST
                )
        form = PaymentChargeForm(request.data, campaign=campaign)
        if not form.is_valid():
            return Response(str(form.errors), status=status.HTTP_400_BAD_REQUEST)
        d = form.cleaned_data

        # Get card and customer
        card = d['card']
        customer = customers.get_customer_for_user(request.user)
        if not customer:
            customer = customers.create(request.user, card=card, plan=None, charge_immediately=False)
            card = Card.objects.get(customer=customer)
        else:
            # Check if we have the card the user is using
            # and if not, create it
            card_fingerprint = stripe.Token.retrieve(card)['card']['fingerprint']
            cards_with_fingerprint = Card.objects.filter(customer=customer, fingerprint=card_fingerprint)
            if cards_with_fingerprint.exists():
                card = cards_with_fingerprint[0]
            else:
                card = sources.create_card(customer=customer, token=card)

        # Create charge
        num_shares = d['num_shares']
        amount = decimal.Decimal(campaign.total(num_shares))
        try:
            charge = charges.create(amount=amount, customer=customer.stripe_id, source=card)
        except stripe.CardError as e:
            return Response(e.message, status=status.HTTP_400_BAD_REQUEST)
        Investment.objects.create(charge=charge, campaign=campaign, num_shares=num_shares)
        return Response(status=status.HTTP_205_RESET_CONTENT)
Пример #11
0
def process_free_charge(request):
    if request.is_ajax():

        # Charge the user's card:
        customer = Customer.objects.filter(user_id=request.user).first()
        if customer == None:
            customer = customers.create(user=request.user)
        plan = Plan.objects.get(stripe_id=request.POST['plan'])
        coupon = request.POST['coupon']
        #should check that it is actually free before processing

        try:
            subs = subscriptions.create(customer=customer,
                                        plan=plan.stripe_id,
                                        coupon=coupon.upper())
            valid = subscriptions.is_valid(subs)
        except Exception as e:
            return JsonResponse({'valid': False, 'message': e.message})
    return JsonResponse({'valid': valid})
Пример #12
0
    def test_subscribe_update(self):
        """Test update a subscription."""

        customer = customers.create(user=self.normal_user)
        token = stripe_token.create(
            card={
                "number": self.card["card_number"],
                "exp_month": self.card["card_exp_month"],
                "exp_year": self.card["card_exp_year"],
                "cvc": self.card["card_cvc"]
            })
        sources.create_card(customer, token)
        subscriptions.create(customer=customer, plan="MF-MONTHLY")

        self.client.credentials(HTTP_AUTHORIZATION='Token ' +
                                self.normal_user_token.key)

        data = {
            'plan_id': "MF-YEARLY",
        }

        url = reverse('stripe-api:subscription-update')
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        # Check that the customer was created and has a subscription
        customer = Customer.objects.get(user=self.normal_user)
        subscription = Subscription.objects.get(customer=customer)
        self.assertTrue(subscription.plan_id, data['plan_id'])

        if self.display_doc:
            # Generate documentation
            content = {
                'title': "Subscribe",
                'http_method': 'POST',
                'url': url,
                'payload': self.jsonify(data),
                'response': self.jsonify(response.data),
                'response_status': response.status_code,
                'description': ("Subscribe to a give plan with card details.")
            }
            self.doc.display_section(content)
Пример #13
0
 def signup(self, request, user):
     user.name = self.cleaned_data['name']
     if 'publisher' in request.path:
         user.is_publisher = True
         payload = jwt_payload_handler(user)
         token = jwt_encode_handler(payload)
         user.token = token
     else:
         try:
             customer = customers.create(user)
             sources.create_card(customer, request.POST.get("stripeToken"))
             add_on = request.POST.get('amount')
             if add_on != '':
                 add_on = Decimal(add_on)
                 charges.create(amount=add_on,
                                customer=user.customer.stripe_id)
                 user.balance = user.balance + add_on
         except stripe.CardError as e:
             user.delete()
             raise forms.ValidationError(smart_str(e))
     user.save()
Пример #14
0
def upgrade(request):
    if request.is_ajax():

        token = request.POST.get('token_id')
        # Charge the user's card:
        customer = Customer.objects.filter(user_id=request.user).first()
        if customer == None:
            customer = customers.create(user=request.user)
        plan = Plan.objects.get(stripe_id=request.POST['plan'])
        coupon = request.POST['coupon']
        try:
            if coupon == '':
                subs = subscriptions.create(customer=customer,
                                            plan=plan.stripe_id,
                                            token=token)
            else:
                subs = subscriptions.create(customer=customer,
                                            plan=plan.stripe_id,
                                            coupon=coupon.upper(),
                                            token=token)
            valid = subscriptions.is_valid(subs)
        except Exception as e:
            return JsonResponse({'valid': False, 'message': e.message})
    return JsonResponse({'valid': valid})
Пример #15
0
 def customer(self):
     if not hasattr(self, "_customer"):
         self._customer = customers.get_customer_for_user(self.request.user)
         if self._customer is None:
             self._customer = customers.create(self.request.user)
     return self._customer
Пример #16
0
 def check_stripe_customer(self, user):
     try:
         Customer.objects.get(user=user)
     except Customer.DoesNotExist:
         customers.create(user=user, card=self.request.POST['stripeToken'])
     return
Пример #17
0
def handle_user_signed_up(sender, **kwargs):
    log(user=kwargs.get('user'), action='USER_SIGNED_UP', extra={})
    customers.create(kwargs.get('user'))
Пример #18
0
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)
        Cart.objects.create(user=instance)
        customers.create(user=instance)
Пример #19
0
 def check_stripe_customer(self, user):
     try:
         Customer.objects.get(user=user)
     except Customer.DoesNotExist:
         customers.create(user=user, card=self.request.POST['stripeToken'])
     return
Пример #20
0
 def create_customer(self):
     customers.create(user=self.created_user)
Пример #21
0
def handle_user_signed_up(sender, **kwargs):
    log(user=kwargs.get("user"), action="USER_SIGNED_UP", extra={})
    customers.create(kwargs.get("user"))