def setUp(self):
self.user = User.objects.create(first_name = 'test', last_name = 'User', username='******', email='*****@*****.**')
self.braintree_user = SubscriptionManager.create_new_customer(self.user)
self.braintree_user.payment_method_token = "ValidPaymentToken"
self.braintree_user.save()
self.user_no_payment_method = User.objects.create(username="******", email="*****@*****.**")
self.braintree_user_no_payment = SubscriptionManager.create_new_customer(self.user_no_payment_method)
self.user_not_properly_initialised = User.objects.create(username="******", email="*****@*****.**")
self.client = APIClient()
def get_object(self):
"""If the user doesnt have permission to access the provided question, they are given 403 response"""
try:
question = Question.objects.get(pk=self.kwargs[self.lookup_url_kwarg])
except ObjectDoesNotExist:
raise Http404
if question.restricted and not SubscriptionManager.can_user_access_subscription_content(self.request.user):
raise PermissionDenied
return question
def get_object(self):
"""If the user doesnt have permission to access the provided question, they are given 403 response"""
try:
question = Question.objects.get(pk=self.kwargs[self.lookup_url_kwarg])
except ObjectDoesNotExist:
raise Http404
if question.restricted and not SubscriptionManager.can_user_access_subscription_content(self.request.user):
raise PermissionDenied
return question
def get_queryset(self):
"""
Show restricted questions only to Silver+ users. Questions can be
accessed individually by question number or filtered by subtopic
:return:
"""
# No filtering. Just display all questions user has permissions for
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return Question.objects.all()
else:
return Question.objects.filter(restricted=False)
def get_queryset(self):
"""
Show restricted questions only to Silver+ users. Questions can be
accessed individually by question number or filtered by subtopic
:return:
"""
# No filtering. Just display all questions user has permissions for
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return Question.objects.all()
else:
return Question.objects.filter(restricted=False)
def setUp(self):
self.user = User.objects.create(first_name='test',
last_name='User',
username='******',
email='*****@*****.**')
self.braintree_user = SubscriptionManager.create_new_customer(
self.user)
self.user_not_initialized_properly = User.objects.create(
username="******", email="madeup.madeup.com")
self.client = APIClient()
def setUp(self):
self.user = User.objects.create(first_name = 'test', last_name = 'User', username='******', email='*****@*****.**')
self.braintree_user = SubscriptionManager.create_new_customer(self.user)
self.user_not_initialized = User.objects.create(username = "******", email="*****@*****.**")
self.valid_payment_nonce = "ValidPaymentNonce"
self.invalid_payment_nonce = "InvalidPaymentNonce"
self.client = APIClient()
when(SubscriptionManager).change_payment_method(self.braintree_user,self.valid_payment_nonce).thenReturn(True)
when(SubscriptionManager).change_payment_method(self.braintree_user,self.invalid_payment_nonce).thenRaise(BraintreeError())
def get_queryset(self):
search_terms = self.kwargs.get('search_terms', None)
if search_terms is None:
raise ValidationError("Must provide a search term")
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
questions = Question.objects.all()
else:
questions = Question.objects.filter(restricted=False)
relevant_questions = watson_filter(questions, search_terms)
if relevant_questions.exists():
return relevant_questions
else:
raise Http404
def get_queryset(self):
search_terms = self.kwargs.get('search_terms', None)
if search_terms is None:
raise ValidationError("Must provide a search term")
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
questions = Question.objects.all()
else:
questions = Question.objects.filter(restricted=False)
relevant_questions = watsonfilter(questions, search_terms)
if relevant_questions.exists():
return relevant_questions
else:
raise Http404
def create(self, validated_data):
"""Register a new user. Also create a Braintree account for them."""
username = validated_data.get('username', None)
email = validated_data.get('email', None)
password = validated_data.get('password1', None)
first_name = validated_data.get('first_name', None)
last_name = validated_data.get('last_name', None)
try:
with transaction.atomic():
user = User.objects.create_user(username,
email=email,
password=password,
first_name=first_name,
last_name=last_name)
emailaddress = EmailAddress(user=user, email=email)
user.save()
emailaddress.save()
emailaddress.send_confirmation()
SubscriptionManager.create_new_customer(user)
except Exception as e:
logging.exception("Could not register new user.")
raise serializers.ValidationError(e.message)
return user
def get_queryset(self):
try:
subtopics = Subtopic.objects.filter(topic=self.kwargs[self.lookup_url_kwarg])
except:
raise Http404
questions_r = Question.objects.filter(subtopic__in=subtopics)
if not questions_r.exists():
raise Http404 # Topic is empty (contains no questions)
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return questions_r # Give privileged user all questions
questions = Question.objects.filter(subtopic__in=subtopics, restricted=False)
if not questions.exists():
# Catch case where subtopic exists,
# but all questions in it are restricted
raise PermissionDenied
return questions
def get_queryset(self):
try:
subtopics = Subtopic.objects.filter(topic=self.kwargs[self.lookup_url_kwarg])
except:
raise Http404
questions_r = Question.objects.filter(subtopic__in=subtopics)
if not questions_r.exists():
raise Http404 # Topic is empty (contains no questions)
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return questions_r # Give privileged user all questions
questions = Question.objects.filter(subtopic__in=subtopics, restricted=False)
if not questions.exists():
# Catch case where subtopic exists,
# but all questions in it are restricted
raise PermissionDenied
return questions
def get_queryset(self):
topic = self.kwargs.get('topic', None)
subtopic = self.kwargs.get('subtopic', None)
if topic is not None and subtopic is not None:
try:
subtopic_pk = Subtopic.objects.get(topic=topic, name=subtopic)
except:
raise Http404
questions_r = Question.objects.filter(subtopic=subtopic_pk)
if not questions_r.exists():
# User picked an empty topic
raise Http404
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return questions_r
questions = Question.objects.filter(subtopic=subtopic_pk, restricted=False)
if not questions.exists():
# Catch case where subtopic exists,
# but all questions in it are restricted
raise PermissionDenied
return questions
def get_queryset(self):
topic = self.kwargs.get('topic', None)
subtopic = self.kwargs.get('subtopic', None)
if topic is not None and subtopic is not None:
try:
subtopic_pk = Subtopic.objects.get(topic=topic, name=subtopic)
except:
raise Http404
questions_r = Question.objects.filter(subtopic=subtopic_pk)
if not questions_r.exists():
# User picked an empty topic
raise Http404
if SubscriptionManager.can_user_access_subscription_content(self.request.user):
return questions_r
questions = Question.objects.filter(subtopic=subtopic_pk, restricted=False)
if not questions.exists():
# Catch case where subtopic exists,
# but all questions in it are restricted
raise PermissionDenied
return questions
def setUp(self):
self.user = User.objects.create(first_name='test',
last_name='User',
username='******',
email='*****@*****.**')
self.braintree_user = SubscriptionManager.create_new_customer(
self.user)
self.user_not_initialized = User.objects.create(
username="******", email="*****@*****.**")
self.valid_payment_nonce = "ValidPaymentNonce"
self.invalid_payment_nonce = "InvalidPaymentNonce"
self.client = APIClient()
when(SubscriptionManager).change_payment_method(
self.braintree_user, self.valid_payment_nonce).thenReturn(True)
when(SubscriptionManager).change_payment_method(
self.braintree_user,
self.invalid_payment_nonce).thenRaise(BraintreeError())
def setUp(self):
self.user = User.objects.create(first_name = 'test', last_name = 'User', username='******', email='*****@*****.**')
SubscriptionManager.create_new_customer(self.user)
self.client = APIClient()
def setUp(self):
self.client = APIClient()
self.user = User.objects.create(first_name='test',
last_name='User',
username='******',
email='*****@*****.**')
self.braintree_user = SubscriptionManager.create_new_customer(
self.user)
self.braintree_user.subscription_id = "ValidSubscriptionID"
self.braintree_user.save()
self.user_pending_cancel = User.objects.create(
username='******', email='*****@*****.**')
self.braintree_user_pending_cancel = SubscriptionManager.create_new_customer(
self.user_pending_cancel)
self.braintree_user_pending_cancel.subscription_id = "ValidSubscriptionID"
self.braintree_user_pending_cancel.pending_cancel = True
self.braintree_user_pending_cancel.save()
self.user_not_subscribed = User.objects.create(
username="******", email="*****@*****.**")
self.braintree_user_not_subscribed = SubscriptionManager.create_new_customer(
self.user_not_subscribed)
self.user_not_subscribed_return = mock()
self.user_subscribed_active_return = mock()
self.user_subscribed_active_return.status = braintree.Subscription.Status.Active
self.user_subscribed_active_return.billing_period_start_date = datetime.datetime(
2016, 8, 7)
self.user_subscribed_active_return.billing_period_end_date = datetime.datetime(
2017, 8, 7)
self.user_subscribed_active_return.created_at = datetime.datetime(
2017, 8, 7)
self.user_subscribed_active_return.price = 30
self.user_subscribed_pending_return = mock()
self.user_subscribed_pending_return.status = braintree.Subscription.Status.Pending
self.user_subscribed_pending_return.billing_period_start_date = datetime.datetime(
2016, 8, 7)
self.user_subscribed_pending_return.billing_period_end_date = datetime.datetime(
2017, 8, 7)
self.user_subscribed_pending_return.created_at = datetime.datetime(
2017, 8, 7)
self.user_subscribed_pending_return.price = 30
self.user_subscribed_past_due_return = mock()
self.user_subscribed_past_due_return.status = braintree.Subscription.Status.PastDue
self.user_subscribed_past_due_return.billing_period_start_date = datetime.datetime(
2016, 8, 7)
self.user_subscribed_past_due_return.billing_period_end_date = datetime.datetime(
2017, 8, 7)
self.user_subscribed_past_due_return.created_at = datetime.datetime(
2017, 8, 7)
self.user_subscribed_past_due_return.price = 30
self.user_subscribed_cancelled_return = mock()
self.user_subscribed_cancelled_return.status = braintree.Subscription.Status.Canceled
self.user_subscribed_cancelled_return.billing_period_start_date = datetime.datetime(
2016, 8, 7)
self.user_subscribed_cancelled_return.billing_period_end_date = datetime.datetime(
2017, 8, 7)
self.user_subscribed_cancelled_return.created_at = datetime.datetime(
2017, 8, 7)
self.user_subscribed_cancelled_return.price = 30
self.user_subscribed_expired_return = mock()
self.user_subscribed_expired_return.status = braintree.Subscription.Status.Expired
self.user_subscribed_expired_return.billing_period_start_date = datetime.datetime(
2016, 8, 7)
self.user_subscribed_expired_return.billing_period_end_date = datetime.datetime(
2017, 8, 7)
self.user_subscribed_expired_return.created_at = datetime.datetime(
2017, 8, 7)
self.user_subscribed_expired_return.price = 30
def post(self, request, format=None):
# Restrict access to paid users
if not SubscriptionManager.can_user_access_subscription_content(
request.user):
raise PermissionDenied
# Get raw questions
topic_list = request.data['topic_list']
max_questions = int(request.data['max_questions'])
# Catch empty topic list
if len(topic_list) < 1:
raise ValidationError("Topic list provided was empty")
# Catch zero or negative max questions
if max_questions < 1:
raise ValidationError("Must have at least 1 question in a quiz")
# Work out the max number of questions available in database per topic
total_questions_available = 0
questions_available_per_topic = []
for topic in topic_list:
subtopic = Subtopic.objects.get(topic=topic['topic'],
name=topic['subtopic'])
questions = Question.objects.filter(subtopic=subtopic)
count = questions.count()
total_questions_available += count
questions_available_per_topic.append(count)
# Now work out target number of questions per topic
if total_questions_available < max_questions:
max_questions = total_questions_available
enough_questions_available = False
target_questions_per_topic = max_questions / len(topic_list)
# Redistribute based on limits
# Reduce questions required for topics with too few questions
questions_per_topic = [target_questions_per_topic] * len(topic_list)
questions_left_to_assign = max_questions
for index, questions_for_topic in enumerate(questions_per_topic):
if questions_per_topic[index] > questions_available_per_topic[
index]:
questions_per_topic[index] = questions_available_per_topic[
index]
questions_left_to_assign -= questions_per_topic[index]
# Now try to add questions for other topics
while questions_left_to_assign > 0:
for index, qNo in enumerate(questions_per_topic):
if qNo < questions_available_per_topic[index]:
questions_per_topic[index] += 1
questions_left_to_assign -= 1
if questions_left_to_assign == 0:
break
# Now combine topic list with questions for each
topics_and_question_numbers = zip(topic_list, questions_per_topic)
# build queryset
queryset = []
for topic, number_of_questions in topics_and_question_numbers:
subtopic = Subtopic.objects.get(topic=topic['topic'],
name=topic['subtopic'])
questions = Question.objects.filter(
subtopic=subtopic).order_by('?')
queryset = list(chain(queryset, questions[0:number_of_questions]))
serializer = QuestionSerializer(queryset, many=True)
return Response(serializer.data)
def post(self,request,format=None):
# Restrict access to paid users
if not SubscriptionManager.can_user_access_subscription_content(request.user):
raise PermissionDenied
# Get raw questions
topic_list = request.data['topic_list']
max_questions = int(request.data['max_questions'])
# Catch empty topic list
if len(topic_list) < 1:
raise ValidationError("Topic list provided was empty")
# Catch zero or negative max questions
if max_questions < 1:
raise ValidationError("Must have at least 1 question in a quiz")
# Work out the max number of questions available in database per topic
total_questions_available = 0
questions_available_per_topic = []
for topic in topic_list:
subtopic = Subtopic.objects.get(topic=topic['topic'],name=topic['subtopic'])
questions = Question.objects.filter(subtopic=subtopic)
count = questions.count()
total_questions_available += count
questions_available_per_topic.append(count)
# Now work out target number of questions per topic
if total_questions_available < max_questions:
max_questions = total_questions_available
enough_questions_available = False
target_questions_per_topic = max_questions / len(topic_list)
# Redistribute based on limits
# Reduce questions required for topics with too few questions
questions_per_topic = [target_questions_per_topic] * len(topic_list)
questions_left_to_assign = max_questions
for index,questions_for_topic in enumerate(questions_per_topic):
if questions_per_topic[index] > questions_available_per_topic[index]:
questions_per_topic[index] = questions_available_per_topic[index]
questions_left_to_assign -= questions_per_topic[index]
# Now try to add questions for other topics
while questions_left_to_assign > 0:
for index, qNo in enumerate(questions_per_topic):
if qNo < questions_available_per_topic[index]:
questions_per_topic[index] += 1
questions_left_to_assign -= 1
if questions_left_to_assign == 0:
break;
# Now combine topic list with questions for each
topics_and_question_numbers = zip(topic_list,questions_per_topic)
# build queryset
queryset = []
for topic,number_of_questions in topics_and_question_numbers:
subtopic = Subtopic.objects.get(topic=topic['topic'],name=topic['subtopic'])
questions = Question.objects.filter(subtopic=subtopic).order_by('?')
queryset = list(chain(queryset, questions[0:number_of_questions]))
serializer = QuestionSerializer(queryset, many=True)
return Response(serializer.data)