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 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 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 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_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 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 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)})
