def candidates_image_view(request, ID):
qs = Candidates.objects.all().order_by('pk')
first = qs.first()
last = qs.last()
entry = Candidates.objects.get(id=ID)
coords = entry.Transient_file.coords.replace('(', '').replace(')', '')
# If user is on first image page, previous button keeps them on same page. If they are on last image page, next button keeps them on same page.
if entry.pk == first.pk:
next_entry = next_in_order(entry, qs=qs)
previous_entry = entry
elif entry.pk == last.pk:
next_entry = entry
previous_entry = prev_in_order(entry, qs=qs)
else:
next_entry = next_in_order(entry, qs=qs)
previous_entry = prev_in_order(entry, qs=qs)
next_id = next_entry.pk
previous_id = previous_entry.pk
return render(
request, 'candidates/candidate_images.html', {
'entry': entry,
'next_id': next_id,
'previous_id': previous_id,
'coords': coords
})
def test_order_on_nullable(self):
qs = Post.objects.all().order_by('author')
print("QS", qs)
first = qs.first()
self.assertEqual(first, self.post2)
print("1")
second = next_in_order(first, qs)
self.assertEqual(second, self.post3)
print("2")
third = next_in_order(second, qs)
self.assertEqual(third, self.post1)
print("3")
fourth = next_in_order(third, qs)
self.assertEqual(fourth, None)
print("4")
fourth_loop = next_in_order(third, qs, loop=True)
self.assertEqual(fourth_loop, self.post2)
print("5")
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
print("6")
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.post1)
def update_details(request, pk):
user_to_update = UserDetail.objects.get(id=pk)
user = UserDetail.objects.get(id=pk)
suppose = 'true'
print("level 1")
if request.method == "POST":
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
user.first_name = first_name
user.last_name = last_name
user.email = email
user.save()
print("user saved")
while suppose == "true":
hash_obj = HashTable.objects.get(user=user)
prev_hash_obj = prev_in_order(hash_obj)
if prev_hash_obj != None:
# print("hi")
prev_hash = prev_hash_obj.current_hash
hash_str = prev_hash + user.first_name + user.last_name + user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
print(hash_obj.user, prev_hash, current_hash, " ", hash_str)
hash_obj.previous_hash = prev_hash
hash_obj.current_hash = current_hash
hash_obj.save()
print("hash object saved in not first node")
user = next_in_order(user)
# print(user)
if user == None:
print(" false in not first node")
suppose = "false"
else:
# print('no prev')
prev_hash = "0"
hash_str = prev_hash + user.first_name + user.last_name + user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
print(hash_obj, prev_hash, current_hash, " ", hash_str)
hash_obj.previous_hash = prev_hash
hash_obj.current_hash = current_hash
hash_obj.save()
print("hash object saved in first node")
user = next_in_order(user)
# print(user)
if user == None:
print(" false in first node")
suppose = "false"
# updating last hash object
last_hash_obj = HashTable.objects.last()
prev_hash_of_last = prev_in_order(last_hash_obj).current_hash
last_hash_obj.previous_hash = prev_hash_of_last
last_hash_obj.save()
print("last hash saved")
return redirect('home')
return render(request, 'update_detail.html', {'user': user_to_update})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# context['previous_object'] = prev_in_order(context['empresa'])
# context['next_object'] = next_in_order(context['empresa'])
# custom ordering
emp_id = context['empresa'].id
com_id = context['empresa'].comercial_id
qs = models.Empresa.objects.filter(
comercial=com_id).order_by('razon_social')
newest = qs.get(id=emp_id)
context['previous_object'] = prev_in_order(newest, qs=qs)
context['next_object'] = next_in_order(newest, qs=qs)
context['domicilios'] = context['empresa'].domicilios.filter(
active=True)
context['comunicaciones'] = context['empresa'].comunicaciones.filter(
active=True)
context['contactos'] = context['empresa'].contactos.filter(active=True)
context['actividades'] = context['empresa'].actividades.filter(
active=True)
# context['empresa'].contactos.filter(tipo='movil').filter(active=True)
# cargamos los celulares de los contactos
# for reg in context['contactos']:
# reg.comunicaciones = reg.comunicaciones.filter(tipo='movil').filter(active=True)
return context
def chapter_page(request, slug, vol, num, page):
try:
vol, num, page = int(vol), float(num), int(page)
except (ValueError, TypeError):
raise Http404
if page == 0:
raise Http404
chapters = {
'all': Chapter.objects.filter(series__slug=slug),
'curr': None,
'prev': None,
'next': None
}
try:
chapters['curr'] = chapters['all'] \
.prefetch_related('pages').get(number=num, volume=vol)
except Chapter.DoesNotExist:
raise Http404
chapters['next'] = next_in_order(chapters['curr'], qs=chapters['all'])
chapters['prev'] = prev_in_order(chapters['curr'], qs=chapters['all'])
all_pages = chapters['curr'].pages.all()
if page > len(all_pages):
raise Http404
return render(request, 'chapter.html', {
'all_chapters': chapters['all'].reverse(),
'curr_chapter': chapters['curr'],
'next_chapter': chapters['next'],
'prev_chapter': chapters['prev'],
'all_pages': all_pages,
'curr_page': all_pages.get(number=page)
})
def get(self, request, **kwargs):
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
session.content_id = kwargs['content_id']
contents = Content.objects.filter(
taleid=kwargs['tale_id']).order_by('order')
curr_content = Content.objects.get(id=kwargs['content_id'])
next_content = next_in_order(curr_content, qs=contents)
if next_content is None:
next_content_url = reverse('tale_app:TaleEnd',
kwargs={
'child_id': kwargs['child_id'],
'tale_id': kwargs['tale_id'],
})
else:
next_content_url = reverse('tale_app:TaleContent',
kwargs={
'child_id': kwargs['child_id'],
'tale_id': kwargs['tale_id'],
'content_id': next_content.id
})
context = {
'form': ReportPicture(),
'next_content_url': next_content_url,
}
return render(request, 'tale_app/upload.html', context)
def post(request, post_id):
post = get_object_or_404(Post, post_id=str(post_id))
next_post = next_in_order(post)
print(next_post)
comments = post.get_comments
form = CommentForm(request.POST, request.FILES or None)
if request.method == "POST":
if form.is_valid():
parent_obj = None
try:
parent_id = int(request.POST.get('parent_id'))
except:
parent_id = None
if parent_id:
parent_obj = Comment.objects.get(id=parent_id)
if parent_obj:
# create replay comment object
reply_comment = form.save(commit=False)
# assign parent_obj to replay comment
reply_comment.parent = parent_obj
form.instance.post = post
form.instance.user = request.user
form.save()
return redirect(reverse("post", kwargs={
'post_id': post.post_id,
}))
context = {
'post': post,
'next_post': next_post,
'form': form,
'comments': comments,
}
return render(request, 'post.html', context)
def handle(self, *args, **options):
for item in TransactionKeys.objects.all():
if not item == TransactionKeys.objects.last(
) and item.key_for_user == next_in_order(
item, TransactionKeys.objects.all()).key_for_user:
item.delete()
print("Success!")
def blogPost(request, slug):
allPosts = Post.objects.all()
post = Post.objects.filter(slug=slug).first()
next = next_in_order(post)
prev = prev_in_order(post)
# getting comment for above post
comments = BlogComment.objects.filter(post=post, parent=None)
# getting replies
replies = BlogComment.objects.filter(post=post).exclude(parent=None)
replyDict = {}
for reply in replies:
if reply.parent.sno not in replyDict.keys():
replyDict[reply.parent.sno] = [reply]
else:
replyDict[reply.parent.sno].append(reply)
print("replydict is", replyDict)
context = {
'post': post,
'next': next,
'prev': prev,
'comments': comments,
'user': request.user,
'replyDict': replyDict
}
return render(request, "blog/blogPost.html", context)
def TOC_update(request, id=None):
print(id)
instance = get_object_or_404(DatafileModel, id=id)
form = TOC_Form(request.POST or None, instance=instance)
# the_next = instance.get_next_by_timestamp()
newest = DatafileModel.objects.all().first()
the_next = next_in_order(instance)
the_prev = prev_in_order(instance)
if form.is_valid():
print("HI")
# form.save()
# data_id = DatafileModel.objects.get(data=instance).id
defecient_selected = form.cleaned_data.get("defecient")
remarks_selected = form.cleaned_data.get("remarks")
new_object = testing_of_controls.objects.create(
defecient=defecient_selected, remarks=remarks_selected, data_id=id)
else:
print(form.errors)
# print(form.non_form_errors())
sampling_id = request.session['sampling_id']
#print(instance.data)
context = {
"sampling_data": sampling.objects.get(pk=sampling_id),
"instance": instance,
"form": form,
"the_prev": the_prev,
"the_next": the_next,
}
return render(request, 'sample_form.html', context)
def get_object(self, queryset=None):
# can bypass idlist and searchlist with own queryset arg
if not queryset:
queryset = self.get_queryset()
# doesn't matter if it is same user, lazy
travel = self.get_travel_for_request().filter(
loggedin_active_tprotections_q)
# required for next/previous token
queryset = queryset.select_related(
"usercomponent", "usercomponent__user",
"usercomponent__user__spider_info").filter(
usercomponent=self.usercomponent).order_by("priority", "id")
ob = get_object_or_404(
queryset,
(~models.Q(travel_protected__in=travel) |
models.Q(ctype__name__in={"SelfProtection", "TravelProtection"})),
token=self.kwargs["token"])
queryset2 = queryset.exclude(
~models.Q(id=ob.id),
info__contains="\x1eunlisted\x1e",
)
ob.previous_object = prev_in_order(ob, queryset2)
ob.next_object = next_in_order(ob, queryset2)
return ob
def start_quiz(request, question_slug):
#there is pass question_slug in question_slug
question = Question.objects.filter(
slug=question_slug).first() #getting question from slug
choices_data = Choice.objects.filter(question_id=question.id)
next_slug = next_in_order(
question) #getting next slug use next_in_order method
if Userquizreletion.objects.filter(
user_id=request.user.id, quiz_id=question.quiz_id).count(
) == 0: #check logged user is exit in db or not
user_quiz_data = Userquizreletion.objects.create(
user_id=request.user.id,
quiz_id=question.quiz_id) #create user_quiz_reletion object
else:
user_quiz_data = Userquizreletion.objects.filter(
user_id=request.user.id, quiz_id=question.quiz_id).first(
) #it is already created so get reletion data
return render(request,
'quiz_app/start_quiz.html',
context={
'question': question,
'choices_data': choices_data,
'next_slug': next_slug.slug if next_slug else '',
'user_quiz_data': user_quiz_data.id
})
def article(request, id):
post = get_object_or_404(Post, id=id)
categories = Category.objects.all()
posts = Post.objects.order_by('-timestamp')
current_post = Post.objects.get(pk=id)
next_post = next_in_order(current_post)
previous_post = prev_in_order(current_post)
form = CommentForm(request.POST or None)
if request.user.is_authenticated:
PostView.objects.get_or_create(user=request.user, post=post)
if request.method == "POST":
if form.is_valid():
form.instance.user = request.user
form.instance.post = post
form.save()
return redirect(reverse("article", kwargs={'id': post.pk}))
context = {
'post': post,
'current_post': current_post,
'next_post': next_post,
'previous_post': previous_post,
'categories': categories,
'posts': posts,
'form': form
}
return render(request, 'article.html', context)
def get_next_lesson(lesson):
next_lesson = next_in_order(lesson, Lesson.objects.all(), prev=False)
if next_lesson:
return dict(success=True,
next_lesson_name=next_lesson.name,
next_lesson_slug=next_lesson.slug)
else:
return dict(success=False)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
qs = Track.objects.all().order_by('id')
current_song = self.get_object()
previous_song = prev_in_order(current_song, qs=qs, loop=True)
next_song = next_in_order(current_song, qs=qs, loop=True)
context['next_song'] = next_song
context['previous_song'] = previous_song
return context
def get_next_exercise_question(request, question_id, exercise_id):
current_question = ExerciseQuestion.objects.get(id=question_id)
all_questions = ExerciseQuestion.objects.filter(exercise=exercise_id)
next_question = next_in_order(current_question, all_questions, prev=False)
if not request.POST.get('test'):
if next_question:
return get_type_of_exercise_question(next_question)
else:
return render_to_response('exercises/end.html')
else:
return get_type_of_exercise_question(current_question)
def test_empty_ordering(self):
qs = Category.objects.all()
first = qs.first()
self.assertEqual(first, self.first_category)
second = next_in_order(first, qs)
self.assertEqual(second, self.second_category)
third = next_in_order(second, qs)
self.assertEqual(third, None)
third_loop = next_in_order(second, qs, loop=True)
self.assertEqual(third_loop, self.first_category)
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.second_category)
class TrackListView(generic.ListView):
model = Track
first = Track.objects.first()
second = next_in_order(first)
prev_in_order(second) == first # True
last = prev_in_order(first, loop=True)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['next_song'] = self.second
context['previous_song'] = self.last
return context
def project(request, slug):
project = Project.objects.get(slug=slug)
qs = Project.objects.filter(is_visible=True)
next_project = next_in_order(project, loop=True, qs=qs)
prev_project = prev_in_order(project, loop=True, qs=qs)
return render(request, 'project.html', {
"project": project,
"next_project": next_project,
"prev_project": prev_project,
})
def to_representation(self, instance):
queryset = Blog.objects.order_by('id')
prev_instance = prev_in_order(instance, qs=queryset)
next_instance = next_in_order(instance, qs=queryset)
serialized_instance = super().to_representation(instance)
serialized_prev = self.__serialize_or_None(prev_instance)
serialized_next = self.__serialize_or_None(next_instance)
return {
'instance': serialized_instance,
'prev_instance': serialized_prev,
'next_instance': serialized_next,
}
def test_default(self):
qs = Post.objects.all()
first = qs.first()
self.assertEqual(first, self.post1)
second = next_in_order(first)
self.assertEqual(second, self.post2)
third = next_in_order(second)
self.assertEqual(third, self.post3)
fourth = next_in_order(third)
self.assertEqual(fourth, None)
fourth_loop = next_in_order(third, loop=True)
self.assertEqual(fourth_loop, self.post1)
prev = prev_in_order(first)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, loop=True)
self.assertEqual(prev_loop, self.post3)
def test_custom(self):
qs = Post.objects.all().order_by('category__title', '-created')
first = qs.first()
self.assertEqual(first, self.post3)
second = next_in_order(first, qs)
self.assertEqual(second, self.post1)
third = next_in_order(second, qs)
self.assertEqual(third, self.post2)
fourth = next_in_order(third, qs)
self.assertEqual(fourth, None)
fourth_loop = next_in_order(third, qs, loop=True)
self.assertEqual(fourth_loop, self.post3)
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.post2)
def image_view(request, field_ID, ID):
qs = Transient_files.objects.filter(field_ID__field_ID=field_ID).order_by(
'mag_1', 'pk')
first = qs.first()
last = qs.last()
entry = Transient_files.objects.get(id=ID)
coords = entry.coords.replace('(', '').replace(')', '')
# If user is on first image page, previous button keeps them on same page. If they are on last image page, next button keeps them on same page.
if entry.pk == first.pk:
next_entry = next_in_order(entry, qs=qs)
previous_entry = entry
elif entry.pk == last.pk:
next_entry = entry
previous_entry = prev_in_order(entry, qs=qs)
else:
next_entry = next_in_order(entry, qs=qs)
previous_entry = prev_in_order(entry, qs=qs)
next_id = next_entry.pk
previous_id = previous_entry.pk
""" If user clicks Add button, then pk of post should be saved to 'candidates' list"""
if request.POST.get('pair_id') == 'Add':
candidate_list.append(entry.pk)
if request.POST.get('pair_id') == 'Remove':
candidate_list.remove(entry.pk)
return render(
request, 'vetting/images.html', {
'entry': entry,
'next_id': next_id,
'previous_id': previous_id,
'coords': coords,
'candidate_list': candidate_list
})
def post(self, request, *args, **kwargs):
form = ReportPicture(request.POST, request.FILES)
if form.is_valid():
print("VALID FORM IN.")
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
content = Content.objects.get(id=kwargs['content_id'])
try:
result = Result.objects.get(session=session, content=content)
result.image = form.cleaned_data['image']
result.time = str(timezone.now())
result.save()
except Result.DoesNotExist:
result = Result(
session=session,
content=content,
time=str(timezone.now()),
image=form.cleaned_data['image'],
)
result.save()
endresult = Result.objects.get(session=session, content=content)
emotion_detction(endresult.id)
# Redirect response
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
session.content_id = kwargs['content_id']
contents = Content.objects.filter(
taleid=kwargs['tale_id']).order_by('order')
curr_content = Content.objects.get(id=kwargs['content_id'])
next_content = next_in_order(curr_content, qs=contents)
if next_content is None:
next_content_url = reverse('tale_app:TaleEnd',
kwargs={
'child_id': kwargs['child_id'],
'tale_id': kwargs['tale_id'],
})
return HttpResponseRedirect(next_content_url)
else:
kwargs['content_id'] = next_content.id
return HttpResponseRedirect(
reverse('tale_app:TaleContent', kwargs=kwargs))
else:
print("Problem with FORM IN.")
return HttpResponseRedirect(
reverse('tale_app:TaleUpload', kwargs=kwargs))
def get_type_of_question(obj):
question = obj
context = {'question': question, 'next_question': next_in_order(obj)}
if question.type == 'default':
return render_to_response('default_test.html', context)
elif question.type == 'image':
return render_to_response('image_test.html', context)
elif question.type == 'input':
return render_to_response('input_test.html', context)
elif question.type == 'video':
return render_to_response('video_test.html', context)
elif question.type == 'juxtaposition':
return render_to_response('juxtaposition.html', context)
elif question.type == 'multiple':
return render_to_response('multiple_answer_test.html', context)
else:
return JsonResponse(dict(success=False, message='Hey'))
def TOC_update(request, id=None):
sampling_id = request.session['sampling_id']
sampling_data = sampling.objects.get(pk=sampling_id)
instance = get_object_or_404(DatafileModel, id=id)
form = TOC_Form(request.POST or None, request.FILES, instance=instance)
# the_next = instance.get_next_by_timestamp()
cycle = sampling_data.Cycle
client = sampling_data.Client
newest = DatafileModel.objects.filter(cycle=cycle).filter(
client=client).order_by('-id')[:10].first()
the_next = next_in_order(instance)
the_prev = prev_in_order(instance)
submitted = False
sampling_id = request.session['sampling_id']
sampling_data = sampling.objects.get(pk=sampling_id)
if form.is_valid() and request.method == "POST":
# data_id = DatafileModel.objects.get(data=instance).id
new_object = testing_of_controls.objects.filter(data=instance).first()
if not new_object:
new_object = testing_of_controls()
new_object.data = instance
new_object.cycle = sampling_data.Cycle
new_object.client = sampling_data.Client
new_object.deficient = form.cleaned_data.get("deficient")
new_object.remarks = form.cleaned_data.get("remarks")
new_object.save()
submitted = True
success_url = request.get_full_path()
procedures = Test_of_Controls.objects.all()[:5]
context = {
"sampling_data": sampling_data,
"instance": instance,
"form": form,
"submitted": submitted,
"procedures": procedures,
"the_prev": the_prev,
"the_next": the_next,
}
return render(request, 'sample_form.html', context)
def post(self, request, *args, **kwargs):
print("POST IN.")
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
content = Content.objects.get(id=kwargs['content_id'])
try:
result = Result.objects.get(session=session, content=content)
result.time = str(timezone.now())
except Result.DoesNotExist:
result = Result(
session=session,
content=content,
time=str(timezone.now()),
)
emotions = [0, 0, 0, 0, 0, 0, 0, 0]
emotions[int(request.POST.get('ID'))] = 1
result.emotion_0 = emotions[0]
result.emotion_1 = emotions[1]
result.emotion_2 = emotions[2]
result.emotion_3 = emotions[3]
result.emotion_4 = emotions[4]
result.emotion_5 = emotions[5]
result.emotion_6 = emotions[6]
result.emotion_7 = emotions[7]
result.save()
child = Child.objects.get(pk=kwargs['child_id'])
if int(request.POST.get('ID')) == content.targetemotion:
child.sessionscore = child.sessionscore + 30
else:
child.sessionscore = child.sessionscore + 10
child.save()
# Redirect response
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
session.content_id = kwargs['content_id']
contents = Content.objects.filter(
taleid=kwargs['tale_id']).order_by('order')
curr_content = Content.objects.get(id=kwargs['content_id'])
next_content = next_in_order(curr_content, qs=contents)
return JsonResponse({'status': True})
def get_context_data(self, **kwargs):
context = super(CryptocurrencyDetailView,
self).get_context_data(**kwargs)
context['next'] = next_in_order(self.object)
context['prev'] = prev_in_order(self.object)
if not self.object.website and self.request.GET.get('refresh'):
try:
page = requests.get('https://coinmarketcap.com/currencies/' +
self.object.slug + '/')
soup = BeautifulSoup(page.text, 'html.parser')
coin = self.get_object()
coin.website = soup.find('span', {
'title': 'Website'
}).findNext('a').get('href')
coin.save()
except:
pass
if not self.object.website_screenshot and self.request.GET.get(
'refresh'):
try:
from selenium import webdriver
driver = webdriver.PhantomJS()
driver.set_window_size(1120, 550)
driver.get(self.object.website)
driver.get_screenshot_as_file('media\website_screenshots\/' +
self.object.slug + '.png')
screenshot = driver.get_screenshot_as_png()
driver.quit()
img = Image.open(BytesIO(screenshot))
box1 = (0, 0, 1120, 800)
box2 = (255, 182)
img = img.crop(box1)
img = img.resize(box2)
buffer_ = BytesIO()
img.save(buffer_, 'PNG')
content_file = ContentFile(buffer_.getvalue())
coin = self.get_object()
coin.website_screenshot.save(self.object.slug + '.png',
content_file,
save=True)
except Exception as error:
print(error)
return context
def get(self, request, *args, **kwargs):
session = Session.objects.get(tale=kwargs['tale_id'],
child=kwargs['child_id'],
completed=False)
session.content_id = kwargs['content_id']
contents = Content.objects.filter(
taleid=kwargs['tale_id']).order_by('order')
curr_content = Content.objects.get(id=kwargs['content_id'])
next_content = next_in_order(curr_content, qs=contents)
if next_content is None:
next_content_url = reverse('tale_app:TaleEnd',
kwargs={
'child_id': kwargs['child_id'],
'tale_id': kwargs['tale_id'],
})
else:
next_content_url = reverse('tale_app:TaleContent',
kwargs={
'child_id': kwargs['child_id'],
'tale_id': kwargs['tale_id'],
'content_id': next_content.id
})
content = Content.objects.get(id=kwargs['content_id'])
if content.type == 0:
renderhtml = 'tale_app/tale.html'
else:
renderhtml = "tale_app/" + str(content.type) + ".html"
child = Child.objects.get(pk=kwargs['child_id'])
emojiset = child.emojitype
child.sessionscore = child.sessionscore + 10
child.save()
emojis = EmojiIcon.objects.filter(
primaryid=emojiset).order_by('emotionid')
context = {
'item': content,
'next_content_url': next_content_url,
'emojis': emojis
}
return render(request, renderhtml, context)
def save_user_answer(request):
#POST parameter (question_id,answer,user_quiz_relation_id)
question_id = int(request.POST['question_id'])
choice = request.POST['choice']
user_quiz_relation_id = int(request.POST['user_quiz_relation_id'])
choice_data = Choice.objects.filter(
choice=choice,
question_id=question_id).values('id').first() #get choice answer text
question = Question.objects.filter(id=question_id).first()
next_slug = next_in_order(
question) # next_in_order use for getting next question
UsersAnswer.objects.create(
question_id=question_id,
quiz_taker_id=user_quiz_relation_id,
choice_id=choice_data['id']) #useranswer object create
if not next_slug: #Check question is not last if question is last to redirect score board page
return HttpResponseRedirect(reverse('score_board'))
#if question is not last to redirect next question
return HttpResponseRedirect(
reverse(('start_quiz'), kwargs={'question_slug': next_slug.slug}))
