def INTERCOM_CUSTOM_DATA(up): from debra import account_helpers brand = account_helpers.get_associated_brand(up) has_brand = brand is not None influencer = account_helpers.get_associated_influencer(up) has_influencer = influencer is not None regprof = None try: regprof = up.user.registrationprofile_set.all()[0] except: pass company_data = None if has_brand: company_data = brand.get_intercom_company_data() data = { "is_blogger": bool(up.blog_page), "is_brand": has_brand or bool(up.temp_brand_domain), "blogger_is_active": up.user.is_active if up.blog_page else None, "brand_stripe_customer_created_at": brand.flag_stripe_customer_created if brand else None, "has_blog_verified": up.blog_verified, "has_brand_verified": has_brand, "has_influencer": has_influencer, "blog_url": up.blog_page, "blog_name": up.blog_name, "ready_to_invite": influencer is not None and influencer.ready_to_invite or False, "activation_key": regprof.activation_key if regprof else None, "expiration_days": settings.ACCOUNT_ACTIVATION_DAYS, "brand_url": brand.domain_name if brand else up.temp_brand_domain, "brand_name": company_data.get('name') if company_data else None, "plan": company_data.get('plan') if company_data else None, "monthly_spend": company_data.get('monthly_spend') if company_data else None, } return data
def shelf_login(request): """ :param request: ``HttpRequest`` instance :return: ``HttpResponse`` instance If the login attempt was successful, return an ``HttpResponse`` with ``status=200`` and ``content`` equals a ``json`` object containing keys: * *url* - the url to go to after a successful login, this defaults to the url provided as a ``next`` parameter in the ``GET`` request, but if that isn't provided, it uses the url set in the :class:`debra.models.UserProfile` instance given by ``valid_user.userprofile.after_login_url`` if the login attempt was not successful, return an ``HttpResponse`` with ``status=500`` and ``content`` equals a ``json`` object containing keys: * *errors* - an array of errors given by ``form.errors`` """ request.invalidate_visitor = True form = ShelfLoginForm(data=request.POST) if form.is_valid(): email = form.cleaned_data['email'] password = form.cleaned_data['password'] next_url = request.GET.get('next', None) valid_user = authenticate(username=email, password=password) if valid_user.username.startswith( "theshelf") and valid_user.username.endswith(".toggle"): return HttpResponseForbidden() login(request, valid_user) brand = account_helpers.get_associated_brand(valid_user) if brand and brand.is_agency: managed = account_helpers.get_managed_brand(valid_user) if managed: request.session["agency_brand"] = managed[0].brand.id return HttpResponse(status=200, content=json.dumps({ 'url': next_url if next_url else valid_user.userprofile.after_login_url })) else: return HttpResponse(status=403, content=json.dumps({'errors': form.errors}))
def track_visit_task(re_usr_id): """ takes request.visitor instance and saves visit fact """ from debra import models from debra import account_helpers collection = get_visitor_tracking_col() if not collection: log.error("No collection to track visit") return user_id = "anonymous" user_email = "anonymous" user = None brand = None if re_usr_id: user = models.User.objects.get(id=re_usr_id) user_id = re_usr_id user_email = user.email brand = account_helpers.get_associated_brand(user) key_data = { 'user_id': user_id, } output_data = { '$set': { 'email': user_email, 'meta': user and INTERCOM_CUSTOM_DATA(user.userprofile) or None, 'brand_meta': brand and brand.get_intercom_company_data() or None, 'last_visit': time.time(), }, '$inc': { 'visits': 1 } } collection.update(key_data, output_data, upsert=True)
def brand_payment(request): """ process a payment for a brand takes requests body as json with following fields - stripeToken - promotionCode - plan - plan name, all plans are listed under :mod:`debra.constants` - amount - obsolete """ import datetime import time request.invalidate_visitor = True user = request.user user_prof = user.userprofile brand = account_helpers.get_associated_brand(user_prof) do_association = False #if the user doesnt have a brand, nothing to do but return if not brand: print "No brand privilages" try: brand = Brands.objects.get( domain_name__iexact=user_prof.temp_brand_domain) except Brands.DoesNotExist: mail_admins( "No brand for user: %i during autoassociation in payment view" % (user_prof.id, )) return HttpResponseBadRequest(content=json.dumps({ 'error': 'We had some trouble with associating brand to your account, no charge was made.' })) except MultipleObjectsReturned: mail_admins( "Multiple brands for user: %i during autoassociation in payment view" % (user_prof.id, )) return HttpResponseBadRequest(content=json.dumps({ 'error': 'We had some trouble with associating brand to your account, no charge was made.' })) if brand.stripe_id: owner = brand.related_user_profiles.get( permissions=UserProfileBrandPrivilages.PRIVILAGE_OWNER ).user_profile msg = "Brand you claimed you are member is already registered and your email doesnt seems to be from its domain. Please contact %s to get access to account." return HttpResponseBadRequest( content=json.dumps({'error': msg % owner.name})) do_association = True try: data = json.loads(request.body) except ValueError: #old code fallback data = {} token = data.get('stripeToken') promo = data.get('promotionCode') plan = data.get('plan') one_time = bool(int(data.get('one_time'))) print "signup to", plan log.error('Signup to {}'.format(plan)) payment_amount = int(data.get('amount', Brands.SUBSCRIPTION_COST)) if not token: #old code fallback token = request.POST['stripeToken'] payment_amount = int( request.POST.get('amount', Brands.SUBSCRIPTION_COST)) plan = "Startup" try: customer_id = brand.stripe_id # if the brand doesn't have a stripe id, create one now (this should happen when their subscription starts) if not customer_id: print "Creating new stripe customer" log.error('Creating new stripe customer') try: customer_id = stripe.Customer.create( card=token, description='{brand} customer created'.format( brand=brand.name)).id except Exception: log.exception('Payment error') return HttpResponseBadRequest( content=json.dumps({'error': 'Payment processing error'})) # print "Success" log.error('Success') brand.stripe_id = customer_id brand.save() customer = stripe.Customer.retrieve(customer_id) is_new_subscription = any([ one_time, not customer.subscriptions.data, customer.subscriptions.data and customer.subscriptions.data[0].plan != plan, ]) if one_time: try: stripe.Charge.create( amount=payment_amount * 100, currency="usd", customer=customer_id, description="{brand} with email {email}".format( brand=brand.name, email=user.email)) except stripe.error.CardError: return HttpResponseBadRequest( content=json.dumps({'error': 'Payment processing error'})) elif customer.subscriptions.data: #remove existing subscriptions if any (plan change) # print "Replace subscriptions" log.error('Replace subscriptions, len={}, data:{}'.format( len(customer.subscriptions.data), customer.subscriptions.data)) sub = customer.subscriptions.data[0] log.error('Last sub: {}'.format(sub)) sub.plan = plan if promo: sub.coupon = promo sub.save() if not promo: try: sub.delete_discount() customer.save() except Exception: pass log.error('Sub updated: {}'.format(sub)) else: # print "New subscription" log.error('New subsciption, promo: '.format(promo)) try: if promo: customer.subscriptions.create(plan=plan, coupon=promo) else: customer.subscriptions.create(plan=plan) except Exception: brand.stripe_id = None brand.is_subscribed = False brand.save() log.exception('Payment error') return HttpResponseBadRequest( content=json.dumps({'error': 'Payment processing error'})) # save payment amount brand.flag_last_payment_amount = payment_amount brand.flag_stripe_customer_created = time.mktime( datetime.datetime.now().timetuple()) # make sure brand is not blacklisted brand.blacklisted = False # make sure brand is not suspended due to payment if is_new_subscription and brand.flag_suspended and brand.flag_suspend_reason == 'stripe_plan_deleted': brand.flag_suspended = False brand.flag_suspend_reason = None brand.save() user_prof.update_intercom() log.error('Success') mp.track( user_prof.user.email, 'Subscribed', { 'brand_url': brand.domain_name, 'amount': payment_amount, # payment_amount is in cents 'promocode': promo, }) # stripe.Charge.create( # amount=payment_amount, # amount in cents # currency="usd", # customer=customer_id, # description="{brand} with email {email}".format(brand=brand.name, email=user.email) # ) if do_association: print "Late association with brand" brand_helpers.sanity_checks(brand) user_prof.temp_brand_domain = None user_prof.save() brand_helpers.connect_user_to_brand(brand, user_prof) print "Refreshing stripe data" log.error('Refreshing stripe data') brand.refresh_stripe_data() brand = Brands.objects.get(id=brand.id) if brand.is_subscribed: print "All good" else: print "Brand is still not subscribed?" if one_time: if request.is_ajax(): return HttpResponse( status=200, content=json.dumps( {'next': reverse("debra.search_views.main_search")})) else: return redirect(reverse("debra.search_views.main_search")) else: if request.is_ajax(): return HttpResponse( status=200, content=json.dumps({ 'next': reverse("debra.account_views.plan_changed_brand", args=(map_plan_names(plan.lower()), )) })) else: return redirect( reverse("debra.account_views.plan_changed_brand", args=(map_plan_names(plan.lower()), ))) except stripe.CardError: brand.stripe_id = None brand.is_subscribed = False brand.save() # The card has been declined return HttpResponseBadRequest( content=json.dumps({'error': 'credit card has been declined'})) except stripe.InvalidRequestError: return HttpResponseBadRequest( content=json.dumps({'error': 'promotion code is invalid'}))
def get_base_brand(self): user = self["user"] if user: return account_helpers.get_associated_brand(user) else: return None