def test_index_handles_logged_in_user(self): #create a session that appears to have a logged in user self.request.session = {"user": "******"} #setup dummy user #we need to save user so user -> badges relationship is created u = User(email="*****@*****.**") u.save() with mock.patch('main.views.User') as user_mock: #tell the mock what to do when called config = {'get_by_id.return_value': u} user_mock.configure_mock(**config) #run the test resp = index(self.request) #ensure we return the state of the session back to normal self.request.session = {} u.delete() #we are now sending a lot of state for logged in users, rather than #recreating that all here, let's just check for some text #that should only be present when we are logged in. self.assertContains(resp, "Report back to base")
def register(request): user = None # checks if the http request is POST if request.method == 'POST': form = UserForm(request.POST) # form validation if form.is_valid(): #Uses stripe API to create a customer in stripe # update based on your billing method (subscription vs one time) # pdb.set_trace() customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], # card=form.cleaned_data['stripe_token'], card={ 'number': '4242424242424242', 'exp_month': 10, 'exp_year': 2018, }, plan="gold", ) # customer = stripe.Charge.create( # description = form.cleaned_data['email'], # card = form.cleand_data['stripe_token'], # amount = "5000" # currency = "usd" # ) user = User( name=form.cleaned_data['name'], email=form.cleaned_data['email'], last_4_digits=form.cleaned_data['last_4_digits'], stripe_id=customer.id, ) # set_password takes care of password hasing # ensure encrypted password user.set_password(form.cleaned_data['password']) try: user.save() except IntegrityError: form.addError(user.email + ' is already a member') else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'register.html', { 'form': form, 'months': range(1, 13), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2011, 2037), }, context_instance=RequestContext(request) )
def test_index_handles_logged_in_user(self): # create user for lookup and index from payments.models import User user = User( name = 'jj', email = '*****@*****.**', ) user.save() # code snippet # verify that the response returns the page for the logged in user request_factory = RequestFactory() request = request_factory('/') # create session that appears to have user logged in request.session = {"user" : "1"} #request the index page resp = index(request) # verify it returns the page for the logged in user self.assertEquals( resp.content, render_to_response('user.html'), {"user" : user}).content self.assertTemplateUsed(resp, 'user.htlm')
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) print("@@@@@@@@@@@@@@@@@@@@@@@@@@@") print(request) print("@@@@@@@@@@@@@@@@@@@@@@@@@@@") print(form) if form.is_valid(): #update based on your billing method (subscription vs one time) customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) # customer = stripe.Charge.create( # description = form.cleaned_data['email'], # card = form.cleaned_data['stripe_token'], # amount="5000", # currency="usd" # ) user = User( name=form.cleaned_data['name'], email=form.cleaned_data['email'], last_4_digits=form.cleaned_data['last_4_digits'], stripe_id=customer.id, ) #ensure encrypted password user.set_password(form.cleaned_data['password']) try: user.save() except IntegrityError: form.addError(user.email + ' is already a member') else: request.session['user'] = user.pk return redirect('/') else: form = UserForm() return render( request, 'register.html', { 'form': form, 'months': range(1, 12), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2011, 2036), }, )
def test_create_user_function_throws_Integrity_error(self): try: with trans.atomic(): # Helps fix troubles with databse transaction managment User.create('test_user','*****@*****.**','pass','1234','11').save() except IntegrityError: pass else: raise Exception('Exception was`t trown')
def test_registering_user_twice_cause_error_msg(self): # create a user with same email so we get an integrity error user = User(name='test_user', email='*****@*****.**') user.save() # now create the request used to test the view self.request.session = {} self.request.method = 'POST' self.request.POST = { 'email': '*****@*****.**', 'name': 'test_user', 'stripe_token': '4242424242424242', 'last_4_digits': '4242', 'password': '******', 'ver_password': '******', } # create our expected form expected_form = UserForm(self.request.POST) expected_form.is_valid() expected_form.addError('[email protected] is already a member') # create the expected html html = render_to_response( 'register.html', { 'form': expected_form, 'months': range(1, 12), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': None, 'years': range(2011, 2036), } ) # mock out stripe so we don't hit their server with mock.patch('stripe.Customer') as stripe_mock: config = {'create.return_value': mock.Mock()} stripe_mock.configure_mock(**config) # run the test resp = register(self.request) # verify that we did things correctly self.assertEquals(resp.status_code, 200) self.assertEquals(self.request.session, {}) # assert there is only one record in the database. users = User.objects.filter(email='*****@*****.**') #self.assertEquals(len(users), 1) # check actual return self.assertEquals(resp.content, html.content)
def test_registering_user_twice_cause_error_msg(self): try: with transaction.atomic(): user = User(name = 'pyRock', email = '*****@*****.**') user.save() self.request.session = {} self.request.method = 'POST' self.request.POST = { 'email': '*****@*****.**', 'name': 'pyRock', 'stripe_token': '...', 'last_4_digits': '4242', 'password': '******', 'ver_password': '******', } expected_form = UserForm(self.request.POST) expected_form.is_valid() expected_form.addError('[email protected] is already a member') html = render_to_response( 'register.html', { 'form': expected_form, 'months': list(range(1, 12)), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': None, 'years': list(range(2011, 2036)), } ) with mock.patch('stripe.Customer') as stripe_mock: config = {'create.return_value': mock.Mock()} stripe_mock.configure_mock(**config) resp = register(self.request) users = User.objects.filter(email = '*****@*****.**') #self.assertEquals(len(users), 1) self.assertEqual(resp.status_code, 200) self.assertEqual(self.request.session, {}) except IntegrityError: pass
def register(request): print "USERFORM = " + str(UserForm) user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): # subscription billing print "YO!" print "STRIPE_PUBLISHABLE = " + str(settings.STRIPE_PUBLISHABLE) print "stripe_token = " + form.cleaned_data['stripe_token'] customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) user = User( name=form.cleaned_data['name'], email=form.cleaned_data['email'], last_4_digits=form.cleaned_data['last_4_digits'], stripe_id=customer.id, ) user.set_password(form.cleaned_data['password']) try: user.save() except IntegrityError: print "Already a member bro!" form.addError(user.email + ' is already a member') else: print "Save user payment profile" request.session['user'] = user.pk print request.session['user'] return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'register.html', { 'form': form, 'months': range(1, 12), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2011, 2036), }, context_instance=RequestContext(request) )
def register(request): user = None if request.method == "POST": form = UserForm(request.POST) if form.is_valid(): # update based on your billing method (subscription vs one time) customer = stripe.Customer.create( email=form.cleaned_data["email"], description=form.cleaned_data["name"], card=form.cleaned_data["stripe_token"], plan="gold", ) # customer = stripe.Charge.create( # description=form.cleaned_data['email'], # card=form.cleaned_data['stripe_token'], # amount="5000", # currency="usd" # ) user = User( name=form.cleaned_data["name"], email=form.cleaned_data["email"], last_4_digits=form.cleaned_data["last_4_digits"], stripe_id=customer.id, ) # ensure encrypted password user.set_password(form.cleaned_data["password"]) try: user.save() except IntegrityError: form.addError(user.email + " is already a member") else: request.session["user"] = user.pk return HttpResponseRedirect("/") else: form = UserForm() return render_to_response( "register.html", { "form": form, "months": range(1, 13), "publishable": settings.STRIPE_PUBLISHABLE, "soon": soon(), "user": user, "years": range(2015, 2041), }, context_instance=RequestContext(request), )
def test_index_handles_logged_in_user(self): user = User( name='jj', email='*****@*****.**', ) user.save() self.request.session = {'user': "******"} resp = index(self.request) self.request.session = {} expected_html = render_to_response('user.html', {'user': user}).content self.assertEqual(resp.content, expected_html)
def test_index_handles_logged_in_user(self): user=User(name='jj', email = '*****@*****.**',) user.save() self.request.session={"user":"******"} with mock.patch('main.views.User') as user_mock: config = {'get.return_value': user} user_mock.objects.configure_mock(**config) resp = index(self.request) self.request.session = {} expectedHtml = render_to_response('user.html',{'user':user}).content self.assertEquals(resp.content,expectedHtml)
def test_index_handles_logged_in_user(self): user = User( name='jj', email='*****@*****.**', ) user.save() self.request.session = {'user': '******'} response = index(self.request) self.request.session = {} expected_html = render(self.request, 'user.html', { 'user': user }).content self.assertEquals(response.content, expected_html)
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): # Update based on billing method customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) # customer = stripe.Charge.create( # description=form.cleaned_data['email'], # card=form.cleaned_data['stripe_token'] # amount="5000", # currency="usd", # ) user = User( name=form.cleaned_data['name'], email=form.cleaned_data['email'], last_4_digits=form.cleaned_data['last_4_digits'], stripe_id=customer.id, password=form.cleaned_data['password'], ) # user.set_password(form.cleaned_data['password']) try: user.save() except IntegrityError: form.addError(user.email + 'is already a member') else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'register.html', { 'form': form, 'months': range(1, 12), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2014, 2039), }, context_instance=RequestContext(request), )
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): # update based on your billing method (subscription vs one time) customer = Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) # customer = stripe.Charge.create( # description=form.cleaned_data['email'], # card=form.cleaned_data['stripe_token'], # amount="5000", # currency="usd" # ) cd = form.cleaned_data try: with transaction.atomic(): user = User.create( cd['name'], cd['email'], cd['password'], cd['last_4_digits'], stripe_id='' ) if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd['email']).save() except IntegrityError: import traceback form.addError(cd['email'] + ' is already a member' + traceback.format_exc()) user = None else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'payments/register.html', { 'form': form, 'months': list(range(1, 12)), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': list(range(2011, 2036)), }, context_instance=RequestContext(request) )
def index(request): uid = request.session.get('user') if uid is None: #main landing page market_items=MarketingItem.objects.all() return render_to_response('main/index.html', {'marketing_items': market_items}) else: #membership page status=StatusReport.objects.all().order_by('-when')[:20] announce_date=date.today()-timedelta(days=30) announces=(Announcement.objects.filter(publication_date__gt=announce_date).order_by('-publication_date')) usr=User.get_by_id(uid) badges=usr.badges.all() return render_to_response( 'main/user.html', #{ # 'marketing_items':market_items, #'user': User.get_by_id(uid),'reports':status}, { 'user':usr, 'badges':badges, 'reports':status, 'announces':announces }, context_instance=RequestContext(request) )
def index(request): uid = request.session.get('user') if uid is None: # main landing page market_items = MarketingItem.objects.all() return render_to_response( 'main/index.html', {'marketing_items': market_items} ) else: # membership page status = StatusReport.objects.all().order_by('-when')[:20] announce_date = date.today() - timedelta(days=30) announce = (Announcement.objects.filter( when__gt=announce_date).order_by('-when') ) usr = User.get_by_id(uid) badges = usr.badges.all() return render_to_response( 'main/user.html', { 'user': usr, 'badges': badges, 'reports': status, 'announce': announce }, context_instance=RequestContext(request), )
def test_create_user_function_stores_in_database(self): """TODO: Docstring for test_create_user_function_stores_in_database. :returns: TODO """ user = User.create('test', '*****@*****.**', 'tt', '1234', '22') self.assertEqual(User.objects.get(email='*****@*****.**'), user)
def test_index_handles_logged_in_user(self): #create the user to lookup from payments.models import User user = User( name='jj', email='*****@*****.**', ) #create a session that appears to have a logged in user self.request.session = {'user': '******'} with mock.patch('main.views.User') as user_mock: #Tell the mock what to do when called config = {'get_by_id.return_value': mock.Mock()} user_mock.configure_mock(**config) #request the index page resp = index(self.request) #return session to its prev state self.request.session = {} #verify it returns the page for the logged in user expectedHtml = render_to_response('user.html', {'user': user_mock.get_by_id(1)}) self.assertEquals(resp.content, expectedHtml)
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) print form.is_valid() if form.is_valid(): print 'form passed validation' customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan='gold', ) cd = form.cleaned_data try: user = User.create(cd['name'], cd['email'], cd['password'], cd['last_4_digits'], customer.id) except IntegrityError: form.addError(cd['email'] + ' is already a member') else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response('register.html', { 'form': form, 'months': range(1, 12), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2016, 2036) }, context_instance=RequestContext(request))
def test_index_handles_logged_in_user(self): # create the user needed for user lookup from index page from payments.models import User user = User( name = 'jj', email='*****@*****.**', ) user.save() #create a Mock request object, so we can manipulate the session request_factory = RequestFactory() request = request_factory.get('/') request.session= {'user': '******'} rep = index(request) # verify the response returns the page for the logged in user self.assertEqual(rep.content,render_to_response('user.html', {'user': user}).content)
def register(request): user = None if request.method == "POST": # We only talk AJAX posts now if not request.is_ajax(): return HttpResponseBadRequest("I only speak AJAX nowadays") data = json.loads(request.body.decode()) form = UserForm(data) if form.is_valid(): try: customer = Customer.create( "subscription", email=form.cleaned_data["email"], description=form.cleaned_data["name"], card=form.cleaned_data["stripe_token"], plan="gold", ) except Exception as exp: form.addError(exp) cd = form.cleaned_data try: with transaction.atomic(): user = User.create(cd["name"], cd["email"], cd["password"], cd["last_4_digits"], stripe_id="") if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd["email"]).save() except IntegrityError: resp = json.dumps({"status": "fail", "errors": cd["email"] + " is already a member"}) else: request.session["user"] = user.pk resp = json.dumps({"status": "ok", "url": "/"}) return HttpResponse(resp, content_type="application/json") else: # form not valid resp = json.dumps({"status": "form-invalid", "errors": form.errors}) return HttpResponse(resp, content_type="application/json") else: form = UserForm() return render_to_response( "payments/register.html", { "form": form, "months": list(range(1, 12)), "publishable": settings.STRIPE_PUBLISHABLE, "soon": soon(), "user": user, "years": list(range(2011, 2036)), }, context_instance=RequestContext(request), )
def report(request): if request.method == 'POST': status = request.POST.get("status", "") if status: uid = request.session.get('user') user = User.get_by_id(uid) StatusReport(user=user, status=status).save() return index(request)
def index(request): uid = request.session.get('user') if uid is None: return render_to_response('index.html') else: return render_to_response( 'user.html', {'user': User.get_by_id(uid)} )
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): #update based on your billing method (subscription vs one time) customer = Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) # customer = stripe.Charge.create( # description=form.cleaned_data['email'], # card=form.cleaned_data['stripe_token'], # amount="5000", # currency="usd" # ) cd = form.cleaned_data from django.db import transaction try: with transaction.atomic(): user = User.create(cd['name'], cd['email'], cd['password'], cd['last_4_digits'], stripe_id="") if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd['email']).save() except IntegrityError: import traceback form.addError(cd['email'] + ' is already a member' + traceback.format_exc()) user = None else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'payments/register.html', { 'form': form, 'months': list(range(1, 12)), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': list(range(2011, 2036)), }, context_instance=RequestContext(request) )
def test_create_user_function_stores_in_database(self): """ Tests User.create method """ new_user = User.create('jean', '*****@*****.**', 'password', '1234', '1') test = User.objects.get(email='*****@*****.**') self.assertEquals(test, new_user)
def report(request): if request.method == "post": status = request.POST.get('status', '') # Update the database with the status if status: uid = request.session.get('user') user = User.get_by_id(uid) StatusReport(user=user, status=status).save() return index(request)
def test_index_handles_logged_in_user(self): """ Verifies the right template is used with a logged user """ # create the user needed for user lookup from index page user = User(name='test', email='*****@*****.**') # saves user on DB user.save() # sets session value equals to user ID on DB self.request.session = {'user': '******'} # request the index page resp = index(self.request) # verify it return the page for the logged in user self.assertEquals(resp.content, render_to_response( 'user.html', {'user': user}).content)
def report(request): if request.method == "POST": status = request.POST.get("status", "") # Update database with the status if status: uid = request.session.get('user') user = User.get_by_id(uid) StatusReport(user=user, status=status).save() return index(request)
def test_index_handles_logged_in_user(self): # Create a session that appears to have a logged in user self.request.session = {"user": "******"} u = User(email="*****@*****.**") u.save() with mock.patch('main.views.User') as user_mock: # Tell the mock what to do when called config = {'get_by_id.return_value': u} user_mock.configure_mock(**config) # Run the test resp = index(self.request) # Ensure we return the state of the session back to normal self.request.session = {} u.delete() self.assertContains(resp, "Report back to base")
def test_create_user_already_exists_throws_IntegrityError(self): self.assertRaises( IntegrityError, User.create( "test user", "*****@*****.**", "jj", "1234", 89 ) )
def index(request): uid = request.session.get('user') market_items = MarketingItem.objects.all() if uid is None: return render_to_response('main/index.html', {'marketing_items': market_items}) else: return render_to_response('main/user.html', { 'marketing_items': market_items, 'user': User.get_by_id(uid) })
def index(request): uid = request.session.get('user') if uid is None: return render_to_response('main/index.html') else: status = Status.objects.all().filter().order_by('-time_added')[:20] return render_to_response( 'main/user.html', {'user':User.get_user_by_id(uid), 'report':status}, context_instance=RequestContext(request))
def report(request): if request.method == "POST": status = request.POST.get("status", "") # update the database with the status if status: uid = request.session.get("user") user = User.get_by_id(uid) StatusReport(user=user, status=status).save() # always return something return index(request)
def report(request): if request.method == "POST": status = request.POST.get("status", "") #update the database with the status if status: uid = request.session.get('user') user = User.get_by_id(uid) StatusReport(user=user, status=status).save() #always return something return index(request)
def index(request): """TODO: Docstring for index. :returns: TODO """ uid = request.session.get('user') if uid is None: return render_to_response('index.html') else: return render_to_response( 'user.html', {'user': User.get_by_id(uid)} )
def register(request): user = None if request.method == "POST": form = UserForm(request.POST) if form.is_valid(): if form.cleaned_data["sub_type"] == "monthly": # update based on your billing method(subscription vs onetime) customer = Customer.create( email=form.cleaned_data["email"], description=form.cleaned_data["name"], card=form.cleaned_data["stripe_token"], plan="gold", ) else: customer = Customer.create( email=form.cleaned_data["email"], description=form.cleaned_data["name"], card=form.cleaned_data["stripe_token"], plan="Platinum", ) cd = form.cleaned_data try: with transaction.atomic(): user = User.create(cd["name"], cd["email"], cd["password"], cd["last_4_digits"]) if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd["email"]).save() except IntegrityError: form.addError(cd["email"] + " is already a member") else: request.session["user"] = user.pk return HttpResponseRedirect("/") else: form = UserForm() return render_to_response( "payments/register.html", { "form": form, "months": list(range(1, 12)), "publishable": settings.STRIPE_PUBLISHABLE, "soon": soon(), "user": user, "years": list(range(2011, 2036)), }, context_instance=RequestContext(request), )
def index(request): uid = request.session.get('user') market_items=MarketingItem.objects.all() if uid is None: return render_to_response('main/index.html', {'marketing_items': market_items}) else: return render_to_response( 'main/user.html', {'marketing_items':market_items, 'user': User.get_by_id(uid)} )
def setUpClass(cls): cls.u = User(name="test", email="*****@*****.**") cls.u.save() cls.new_status = StatusReport(user=cls.u, status="hello world") cls.new_status.save() cls.expected_dict = OrderedDict([ ('id', cls.new_status.id), ('user', cls.u.email), ('when', cls.new_status.when), ('status', 'hello world'), ])
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): # update based on your billing method (subscription vs one time) customer = stripe.Customer.create( email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) # customer = stripe.Charge.create( # description=form.cleaned_data['email'], # card=form.cleaned_data['stripe_token'], # amount='5000', # currency='usd' # ) cd = form.cleaned_data try: user = User.create( cd['name'], cd['email'], cd['password'], cd['last_4_digits'], customer.id ) except IntegrityError: form.addError(cd['email'] + ' is already a member') user = None else: request.session['user'] = user.pk return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'register.html', { 'form': form, 'months': range(1, 13), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': range(2011, 2036), }, context_instance=RequestContext(request) )
def test_index_handles_logged_in_user(self): # Create a session that appears to have a logged in user self.request.session={'user':'******'} #setup dummy user #we need to save user so user -> badges relationship is created u=User(email="*****@*****.**") u.save() with mock.patch('main.views.User') as user_mock: # Tell the mock what to do when called config = {'get_by_id.return_value': u}# mock.Mock()} user_mock.configure_mock(**config) #Run the test resp=index(self.request) #ensure we return the state of the session back to normal so #we don't affect other test self.request.session={} #verify it returns the page for the logged in user # expectedHtml = render_to_response( # 'main/user.html', {'user': user_mock.get_by_id(1)}) u.delete() #self.assertEquals(resp.content, expectedHtml.content) self.assertContains(resp,"Report back to base")
def setUpTestData(cls): cls.u = User(name="test", email="*****@*****.**") cls.u.save() cls.new_status = StatusReport(user=cls.u, status="hello world") cls.new_status.save() when = cls.new_status.when.isoformat() if when.endswith('+00:00'): when = when[:-6] + 'Z' cls.expected_dict = OrderedDict([ ('id', cls.new_status.id), ('user', cls.u.email), ('when', when), ('status', 'hello world'), ])
def post_user(request): form = UserForm(request.data) if form.is_valid(): try: # update based on your billing method (subscription vs one time) customer = Customer.create( "subscription", email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) except Exception as exp: form.addError(exp) cd = form.cleaned_data try: with transaction.atomic(): user = User.create(cd['name'], cd['email'], cd['password'], cd['last_4_digits'], stripe_id='') if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd['email']).save() except IntegrityError: form.addError(cd['email'] + ' is already a member') else: request.session['user'] = user.pk resp = {"status": "ok", "url": '/'} return Response(resp, content_type="application/json") resp = {"status": "fail", "errors": form.non_field_errors()} return Response(resp) else: # for not valid resp = {"status": "form-invalid", "errors": form.errors} return Response(resp)
def index(request): uid = request.session.get('user') if uid is None: #main landing page market_items = MarketingItem.objects.all() # ipdb.set_trace() return render_to_response('main/index.html', {'marketing_items': market_items}) else: #membership page # status = StatusReport.objects.all().order_by('-when')[:20] status = StatusReport.objects.latest() return render_to_response( 'main/user.html', { 'user': User.get_by_id(uid), 'reports': status }, context_instance=RequestContext(request), )
def register(request): user = None if request.method == 'POST': # We only talk AJAX posts now if not request.is_ajax(): return HttpResponseBadRequest("I only speak AJAX nowadays") data = json.loads(request.body.decode()) form = UserForm(data) if form.is_valid(): try: customer = Customer.create( "subscription", email=form.cleaned_data['email'], description=form.cleaned_data['name'], card=form.cleaned_data['stripe_token'], plan="gold", ) except Exception as exp: form.addError(exp) cd = form.cleaned_data try: with transaction.atomic(): user = User.create(cd['name'], cd['email'], cd['password'], cd['last_4_digits'], stripe_id="") if customer: user.stripe_id = customer.id user.save() else: UnpaidUsers(email=cd['email']).save() except IntegrityError: resp = json.dumps({ "status": "fail", "errors": cd['email'] + ' is already a member' }) else: request.session['user'] = user.pk resp = json.dumps({"status": "ok", "url": '/'}) return HttpResponse(resp, content_type="application/json") else: # form not valid resp = json.dumps({ "status": "form-invalid", "errors": form.errors }) return HttpResponse(resp, content_type="application/json") else: form = UserForm() return render_to_response('payments/register.html', { 'form': form, 'months': list(range(1, 12)), 'publishable': settings.STRIPE_PUBLISHABLE, 'soon': soon(), 'user': user, 'years': list(range(2011, 2036)), }, context_instance=RequestContext(request))
def setUpClass(cls): cls.factory = APIRequestFactory() cls.test_user = User(email="*****@*****.**") cls.test_user.save()
def index(request): uid = request.session.get('user') if uid is None: return render(request, 'index.html', {'user': None}) else: return render(request, 'user.html', {'user': User.get_by_id(uid)})
def setUpTestData(cls): cls.test_user = User(email="*****@*****.**", name='test user') cls.test_user.save()
def test_create_user_function_stores_in_database(self): user = User.create("test", "*****@*****.**", "tt", "1234", "22") self.assertEquals(User.objects.get(email="*****@*****.**"), user)
def setUpTestData(cls): cls.test_user = User(id=2222, email="*****@*****.**", last_login=datetime.now()) cls.test_user.save()
def setUpTestData(cls): cls.test_user = User(id=2222, email="*****@*****.**") cls.test_user.save()
def setUpClass(cls): cls.u = User(name="test", email="*****@*****.**") cls.u.save()
def setUpClass(cls): cls.test_user = User.create(email="*****@*****.**", name='test user', password="******", last_4_digits="1234")
def index(request): uid = request.session.get('user') if uid is None: return render_to_response('index.html') else: return render_to_response('user.html', {'user': User.get_by_id(uid)})