def index(request):
# if the user is not logged in, show main page
if request.user.is_authenticated:
return redirect('questions')
return SimpleTemplateResponse('website/index.html')
def get_response(self, *args, **kwargs):
context = self.get_context()
context.update(kwargs or {})
return SimpleTemplateResponse(
self.detail_template
or self.get_template_list('views/model_detail.html'), context)
def test_pickling(self):
# Create a template response. The context is
# known to be unpickleable (e.g., a function).
response = SimpleTemplateResponse('first/test.html', {
'value': 123,
'fn': datetime.now,
})
self.assertRaises(ContentNotRenderedError, pickle.dumps, response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(unpickled_response['content-type'],
response['content-type'])
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled reponse doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = ('template_name', 'context_data',
'_post_render_callbacks')
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def _send_validation_email(self, author):
"""
Sends a validation email template to the author's email address.
Creates a timed token for the author to claim.
Todo: Move to a utils module later
"""
credentials = gmail_credentials()
# todo: change to db value
from_email = settings.NOREPLY_EMAIL_ADDRESS
to_email = author.user.email
subject = 'Please verify your email address'
email_template = SimpleTemplateResponse(
'email/verify.html',
{'author': author},
)
mime_text = MIMEText(email_template.render().content.decode('utf-8'),
_subtype='html')
mime_text['to'] = to_email
mime_text['from'] = from_email
mime_text['subject'] = subject
mime_text_bytes = mime_text.as_string().encode()
as_base64 = base64.urlsafe_b64encode(mime_text_bytes)
raw = {'raw': as_base64.decode('utf-8')}
service = build('gmail', 'v1', credentials=credentials)
res = service.users().messages().send(userId=from_email,
body=raw).execute()
def schools_similar_view(request):
schools = School.objects.filter(is_active=True)
num_hints = getattr(settings, 'NUM_HINTS', 10)
if 'postal_code' in request.POST and request.POST['postal_code']:
schools = schools.filter(postal_code=request.POST['postal_code'])
elif 'city' in request.POST and request.POST['city']:
schools = schools.filter(city=request.POST['city'])
elif 'province' in request.POST and request.POST['province']:
schools = schools.filter(province=request.POST['province'])
if 'address' in request.POST and request.POST['address']:
address = request.POST['address']
qobj = Q(address=address)
for w in address.split():
qobj |= Q(address__contains=w)
# priority for schools with a matching part of the address
schools = list(schools.filter(qobj)[:num_hints]) + \
list(schools.filter(~qobj)[:num_hints])
schools = schools[:num_hints]
if schools:
return SimpleTemplateResponse('oi/schools_similar_confirm.html',
{'schools': schools})
else:
return HttpResponse('')
def post(self, request, *args, **kwargs):
"""
We need access to the request object, so we do things here in post rather
than in the form_valid method.
"""
form_data = request.POST
if form_data:
form = ClimateQuestionUserContactForm(form_data)
# Update the question with the email
if form.is_valid():
question_id = request.session.get('question_id')
try:
question = Question.objects.get(pk=question_id)
# This should be exceedingly rare, but just in case :D
except Question.DoesNotExist:
return SimpleTemplateResponse(
'core/new_question_failure.html')
else:
question.user_email = form.cleaned_data['user_email']
question.save()
request.session['question_id'] = None
return super(PostQuestionSubmitPage, self).form_valid(form)
else:
return super(PostQuestionSubmitPage, self).form_invalid(form)
return super(PostQuestionSubmitPage,
self).form_invalid(ClimateQuestionUserContactForm())
def test_assert_not_contains_renders_template_response(self):
""" Test that we can pass in an unrendered SimpleTemplateReponse
without throwing an error.
Refs #15826.
"""
response = SimpleTemplateResponse(Template('Hello'), status=200)
self.assertNotContains(response, 'Bye')
def viewlist_view(self, request):
"""
Same as the change list, but no actions and does not accept post
Note most of this method is a simplification of the overridden method. Blame django for any wackiness
"""
opts = self.model._meta
app_label = opts.app_label
if not self.has_view_permission(request):
raise PermissionDenied
try:
cl = self.get_changelist_instance(request)
except IncorrectLookupParameters:
# Wacky lookup parameters were given, so redirect to the main
# changelist page, without parameters, and pass an 'invalid=1'
# parameter via the query string. If wacky parameters were given
# and the 'invalid=1' parameter was already in the query string,
# something is screwed up with the database, so display an error
# page.
if ERROR_FLAG in request.GET:
return SimpleTemplateResponse('admin/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(f'{request.path}?ERROR_FLAG=1')
# This is used in the backend, do not remove
FormSet = self.get_changelist_formset(request)
formset = cl.formset = FormSet(queryset=cl.result_list)
selection_note_all = ngettext('%(total_count)s selected',
'All %(total_count)s selected',
cl.result_count)
context = dict(
self.admin_site.each_context(request),
module_name=str(opts.verbose_name_plural),
selection_note=_(f'0 of {len(cl.result_list)} selected'),
selection_note_all=selection_note_all %
{'total_count': cl.result_count},
title=cl.title,
is_popup=cl.is_popup,
to_field=cl.to_field,
cl=cl,
has_add_permission=self.has_add_permission(request),
opts=cl.opts,
actions_on_top=self.actions_on_top,
actions_on_bottom=self.actions_on_bottom,
actions_selection_counter=self.actions_selection_counter,
preserved_filters=self.get_preserved_filters(request),
)
request.current_app = self.admin_site.name
return TemplateResponse(
request, self.change_list_template or [
f'admin/{app_label}/{opts.model_name}/change_list.html',
f'admin/{app_label}/change_list.html', 'admin/change_list.html'
], context)
def init_paginator(self):
self.paginator = self.get_paginator(self.getMyQueryset())
self.result_count = self.paginator.count
self.full_result_count = self.getMyQueryset().count
self.can_show_all = self.result_count <= self.list_max_show_all
self.multi_page = self.result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and self.can_show_all) or not self.multi_page:
self.result_list = self.getMyQueryset()._clone()
else:
try:
self.result_list = self.paginator.page(self.page_num +
1).object_list
except InvalidPage:
if ERROR_FLAG in self.request.GET.keys():
return SimpleTemplateResponse(
'xadmin/views/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(self.request.path + '?' +
ERROR_FLAG + '=1')
self.has_more = self.result_count > (
self.list_per_page * self.page_num + len(self.result_list))
def process_template_response(self, request, response):
me, context_data = request.user, response.context_data
#author, me=context_data['forum'].post.author, request.user
Authors = []
for author_app in AUTHOR_APPS:
app = context_data.get(author_app)
if app: Authors.append(app)
#authors=[author for author in Authors if author]
if Authors:
for Author in Authors:
if hasattr(Author, 'post'): author = Author.post.author
elif hasattr(Author, 'tug'):
author = Author.media.last().user.last()
elif hasattr(Author, 'galler'):
author = Author.galler
elif hasattr(Author, 'gallery'):
author = Author.gallery.galler
else:
author = Author.author
if author != me:
return SimpleTemplateResponse(
'permission-not-granted.html') #HttpResponse()
else:
return response
if hasattr(context_data, 'forum'):
print(context_data.forum.post.author == request.user)
print('response', response)
def render_cui(context):
context = context.copy()
context['STATIC_URL'] = settings.STATIC_URL
context['DEBUG'] = settings.DEBUG
context['ticket'] = {'id': 'TICKET_ID'}
context['in_devel'] = True
return SimpleTemplateResponse('cui/cui.html', context)
def approval_as_pdf(request, job_application_id, template_name="approvals/approval_as_pdf.html"):
"""
Displays the approval in pdf format
"""
siae = get_current_siae_or_404(request)
queryset = JobApplication.objects.select_related("job_seeker", "eligibility_diagnosis", "approval", "to_siae")
job_application = get_object_or_404(queryset, pk=job_application_id, to_siae=siae)
if not job_application.can_download_approval_as_pdf:
# Message only visible in DEBUG
raise Http404("Nous sommes au regret de vous informer que vous ne pouvez pas télécharger cet agrément.")
diagnosis = job_application.get_eligibility_diagnosis()
diagnosis_author = None
diagnosis_author_org = None
diagnosis_author_org_name = None
if diagnosis:
diagnosis_author = diagnosis.author.get_full_name()
diagnosis_author_org = diagnosis.author_prescriber_organization or diagnosis.author_siae
if diagnosis_author_org:
diagnosis_author_org_name = diagnosis_author_org.display_name
if not diagnosis and job_application.approval and job_application.approval.originates_from_itou:
# On November 30th, 2021, AI were delivered a PASS IAE
# without a diagnosis for all of their employees.
if not job_application.approval.is_from_ai_stock:
# Keep track of job applications without a proper eligibility diagnosis because
# it shouldn't happen.
# If this occurs too much we may have to change `can_download_approval_as_pdf()`
# and investigate a lot more about what's going on.
# See also migration `0035_link_diagnoses.py`.
raise ObjectDoesNotExist("Job application %s has no eligibility diagnosis." % job_application.pk)
# The PDFShift API can load styles only if it has the full URL.
base_url = request.build_absolute_uri("/")[:-1]
if settings.DEBUG:
# Use staging or production styles when working locally
# as PDF shift can't access local files.
base_url = f"{settings.ITOU_PROTOCOL}://{settings.ITOU_STAGING_DN}"
context = {
"approval": job_application.approval,
"base_url": base_url,
"assistance_url": settings.ITOU_ASSISTANCE_URL,
"diagnosis_author": diagnosis_author,
"diagnosis_author_org_name": diagnosis_author_org_name,
"siae": job_application.to_siae,
"job_seeker": job_application.job_seeker,
}
html = SimpleTemplateResponse(template=template_name, context=context).rendered_content
full_name_slug = slugify(job_application.job_seeker.get_full_name())
filename = f"{full_name_slug}-pass-iae.pdf"
with HtmlToPdf(html, autoclose=False) as transformer:
return FileResponse(transformer.file, as_attachment=True, filename=filename)
def response_delete(self, request, obj_display, obj_id):
opts = self.model._meta
if IS_POPUP_VAR in request.POST:
popup_response_data = json.dumps({
'action': 'delete',
'value': str(obj_id),
})
return SimpleTemplateResponse(
'admin/popup_response.html', {
'popup_response_data': popup_response_data,
})
self.message_user(
request,
_('The %(name)s "%(obj)s" was deleted successfully.') % {
'name': force_text(opts.verbose_name),
'obj': force_text(obj_display),
},
messages.SUCCESS,
)
if self.has_change_permission(request, None):
post_url = self.reverse_url('changelist',
*self.get_base_url_args(request)[:-1])
preserved_filters = self.get_preserved_filters(request)
post_url = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, post_url)
else:
post_url = reverse('admin:index', current_app=self.admin_site.name)
return HttpResponseRedirect(post_url)
def _wrapped_view(request, *args, **kwargs):
enable_instrumentation()
response = view_func(request, *args, **kwargs)
disable_instrumentation()
if isinstance(response, SimpleTemplateResponse):
# We could use ``SingleTemplateResponse`` to catch both
# django and restframework responses. Unfortunately
# the content_type on restframework responses is set
# very late (render), while at the same time django
# defaults it to text/html until then.
try:
response.render()
except jinja2.exceptions.TemplateError as err:
response = SimpleTemplateResponse(
template="400.html",
context={'messages': [str(err)]},
status=400)
response.render()
soup = _inject_edition_tools(
response, request, context=get_edition_tools_context_data())
if soup:
# str(soup) instead of soup.prettify() to avoid
# trailing whitespace on a reformatted HTML textarea
response.content = str(soup)
return response
def response_add(self, request, obj, post_url_continue=None):
'''
This just modifies the normal ModelAdmin process in order to
pass capacity and room options for the added Location along with
the location's name and ID.
'''
IS_POPUP_VAR = '_popup'
TO_FIELD_VAR = '_to_field'
if IS_POPUP_VAR in request.POST:
to_field = request.POST.get(TO_FIELD_VAR)
if to_field:
attr = str(to_field)
else:
attr = obj._meta.pk.attname
value = obj.serializable_value(attr)
popup_response_data = json.dumps({
'value': six.text_type(value),
'obj': six.text_type(obj),
# Add this extra data
'defaultCapacity': obj.defaultCapacity,
'roomOptions': json.dumps([{'id': x.id, 'name': x.name, 'defaultCapacity': x.defaultCapacity} for x in obj.room_set.all()]),
})
# Return a modified template
return SimpleTemplateResponse('core/admin/location_popup_response.html', {
'popup_response_data': popup_response_data,
})
# Otherwise just use the standard ModelAdmin method
return super(LocationAdmin,self).response_add(request, obj, post_url_continue)
def index(request):
current_standup = Standup.current_standup()
return SimpleTemplateResponse('index.html', {
'standup': current_standup,
'following_standup': current_standup.following_standup,
'title': SITE_TITLE,
})
def response_change(self, request, obj):
'''
This just modifies the normal ModelAdmin process in order to
pass capacity and room options for the modified Location along with
the location's name and ID.
'''
IS_POPUP_VAR = '_popup'
TO_FIELD_VAR = '_to_field'
if IS_POPUP_VAR in request.POST:
to_field = request.POST.get(TO_FIELD_VAR)
attr = str(to_field) if to_field else obj._meta.pk.attname
# Retrieve the `object_id` from the resolved pattern arguments.
value = request.resolver_match.args[0]
new_value = obj.serializable_value(attr)
popup_response_data = json.dumps({
'action': 'change',
'value': six.text_type(value),
'obj': six.text_type(obj),
'new_value': six.text_type(new_value),
# Add this extra data
'defaultCapacity': obj.defaultCapacity,
'roomOptions': json.dumps([{'id': x.id, 'name': x.name, 'defaultCapacity': x.defaultCapacity} for x in obj.room_set.all()]),
})
# Return a modified template
return SimpleTemplateResponse('core/admin/location_popup_response.html', {
'popup_response_data': popup_response_data,
})
return super(LocationAdmin,self).response_change(request, obj)
def render(self, name, value, attrs=None, renderer=None):
output = super(TypeaheadTextInput, self).render(
name=name,
value=value,
attrs=attrs,
)
if self.local != "":
self.local = 'local: $.map(' + self.local + ', function(v) { return { value: v }; }),'
if self.prefetch != "":
self.prefetch = '''prefetch: {url: "''' + self.prefetch + '''",
ttl: ''' + str(self.prefetch_ttl * 60000) + ''',
filter: function(list) {
return $.map(list, function(v) { return { value: v }; });
}
},'''
if self.remote != "":
self.remote = '''remote: {url: "''' + self.remote + '''",
filter: function(list) {
return $.map(list, function(v) { return { value: v }; });
}
}'''
stresponse = SimpleTemplateResponse(
"django_typeahead_textinput/typeahead-bloodhound-script.html", {
"typeahead_name": "id_" + name,
"typeahead_local": self.local,
"typeahead_prefetch": self.prefetch,
"typeahead_remote": self.remote
})
stresponse.render()
output += stresponse.rendered_content
return output
def index(request):
order_id = request.GET.get('order_id', '')
context = {'order_id': order_id}
if order_id:
try:
order = Order.objects.get(id=order_id)
context['order_details'] = order
context['line_items'] = order.line_items.annotate(
total=Sum(F('price') * F('quantity'),
output_field=DecimalField(decimal_places=2))).values(
'id',
'order_id',
'item__name',
'price',
'quantity',
'total',
)
context['vat_breakdown'] = order.summarise()
except Order.DoesNotExist:
context['message'] = "Order does not exist"
else:
context['message'] = "Please search for an order"
return SimpleTemplateResponse('index.html', context)
def make_result_list(self):
"""
该方法负责生成数据列表及分页信息. 数据列表会赋值给属性 :attr:`result_list` , 插件可以在该方法后执行一些数据处理.
"""
# Get search parameters from the query string.
# 排序及过滤等处理后的 queryset
self.list_queryset = self.get_list_queryset()
self.ordering_field_columns = self.get_ordering_field_columns()
self.paginator = self.get_paginator()
# 获取当前据数目
self.result_count = self.paginator.count
self.can_show_all = self.result_count <= self.list_max_show_all
self.multi_page = self.result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and self.can_show_all) or not self.multi_page:
self.result_list = self.list_queryset._clone()
else:
try:
self.result_list = self.paginator.page(self.page_num +
1).object_list
except InvalidPage:
# 分页错误, 这里的错误页面需要调整一下
if ERROR_FLAG in self.request.GET.keys():
return SimpleTemplateResponse(
'xadmin/views/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(self.request.path + '?' +
ERROR_FLAG + '=1')
self.has_more = self.result_count > (
self.list_per_page * self.page_num + len(self.result_list))
def sql_explain(request):
"""Returns the output of the SQL EXPLAIN on the given query"""
form = SQLSelectForm(request.POST or None)
if form.is_valid():
sql = form.cleaned_data["raw_sql"]
params = form.cleaned_data["params"]
vendor = form.connection.vendor
cursor = form.cursor
if vendor == "sqlite":
# SQLite's EXPLAIN dumps the low-level opcodes generated for a query;
# EXPLAIN QUERY PLAN dumps a more human-readable summary
# See https://www.sqlite.org/lang_explain.html for details
cursor.execute("EXPLAIN QUERY PLAN %s" % (sql, ), params)
elif vendor == "postgresql":
cursor.execute("EXPLAIN ANALYZE %s" % (sql, ), params)
else:
cursor.execute("EXPLAIN %s" % (sql, ), params)
headers = [d[0] for d in cursor.description]
result = cursor.fetchall()
cursor.close()
context = {
"result": result,
"sql": form.reformat_sql(),
"duration": form.cleaned_data["duration"],
"headers": headers,
"alias": form.cleaned_data["alias"],
}
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse("debug_toolbar/panels/sql_explain.html",
context)
return HttpResponseBadRequest("Form errors")
def upcoming_challenges(request):
challenges = Challenge.objects.filter( \
Q(start_date__gt=timezone.now()) | Q(start_date__isnull=True)).order_by('start_date')
challenges_view = _challenges_to_short_dict(challenges)
challenges_view['title'] = 'Upcoming Challenges'
challenges_view['page_name'] = 'Upcoming'
return SimpleTemplateResponse('list_challenges.html', challenges_view)
def search_new_teammates(request: WSGIRequest, group_id: int) -> JsonResponse:
if request.is_ajax():
if auth.get_user(request).is_anonymous:
return JsonResponse({}, status=404)
team = Group.objects.filter(id=group_id).first()
if team is None:
return JsonResponse({}, status=404)
profile = get_user_profile(request)
if profile.company is None:
return JsonResponse({}, status=403)
user_input = request.GET.get('search', '')
profiles = get_search_result_for_profiles(
profile.company.profile_set.all(), user_input, profile.company)
completed_profiles = _build_teammates(profiles, team, profile)
if len(completed_profiles) == 0:
content = get_render_bad_search(
'По вашему запросу ничего не найдено')
else:
content = SimpleTemplateResponse(
'main/teams/new_future_teammates.html', {
'users': completed_profiles
}).rendered_content
return JsonResponse({'content': content}, status=200)
def ended_challenges(request):
challenges = Challenge.objects.filter(
end_date__lt=timezone.now()).order_by('-start_date')
challenges_view = _challenges_to_short_dict(challenges)
challenges_view['title'] = 'Completed Challenges'
challenges_view['page_name'] = 'Completed'
return SimpleTemplateResponse('list_challenges.html', challenges_view)
def serve_preview(self,
request,
mode_name,
site_name,
revision_id='latest'):
request.is_preview = True
if mode_name == 'json':
Serializer = self.__class__.get_serializer()
latest_revision_as_page = self.get_latest_revision_as_page()
serialized_page = Serializer(instance=latest_revision_as_page)
return JsonResponse(serialized_page.data)
if mode_name == 'react':
path = self.get_url_parts(request)[2] if self.get_url_parts(
request) is not None else '/home'
context = {
'preview_url':
'/{}{}?is_preview&revision={}'.format(site_name, path,
revision_id)
}
return SimpleTemplateResponse(template='preview_wrapper.html',
context=context)
return self.serve(request)
def test_random_category_ad_renders(self):
template = Template(
"{% load adzone_tags %}{% random_category_ad 'sidebar' 'internet-services' %}"
)
response = SimpleTemplateResponse(template)
response.render()
self.assertTrue(response.is_rendered)
def make_result_list(self):
u"""
生成列表页结果数据
result_list
"""
# 排序及过滤等处理后的 queryset
self.list_queryset = self.get_list_queryset()
self.ordering_field_columns = self.get_ordering_field_columns()
self.paginator = self.get_paginator()
# 获取当前据数目
self.result_count = self.get_result_count()
self.paginator._count = self.result_count
if self.can_show_all:
self.can_show_all = self.result_count <= self.list_max_show_all
self.multi_page = self.result_count > self.list_per_page
if (self.show_all and self.can_show_all) or not self.multi_page:
self.result_list = self.list_queryset._clone(
count=self.result_count)
else:
try:
self.result_list = self.paginator.page(self.page_num +
1).object_list
except InvalidPage:
# 分页错误, 这里的错误页面需要调整一下
if defs.ERROR_FLAG in self.request.GET.keys():
return SimpleTemplateResponse(
'xadmin/views/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(self.request.path + '?' +
defs.ERROR_FLAG + '=1')
self.has_more = self.result_count > (
self.list_per_page * self.page_num + len(self.result_list))
def process_view(self, request, view_func, view_args, view_kwargs):
"""Removes kbsite_name from kwargs if present, and attaches the
corresponding KegbotSite instance to the request as the "kbsite" attribute.
If kbsite_name is None, the default site is selected.
"""
kbsite_name = view_kwargs.pop('kbsite_name', None)
if not kbsite_name:
kbsite_name = 'default'
request.kbsite_name = kbsite_name
try:
request.kbsite = models.KegbotSite.objects.get(name=kbsite_name)
except models.KegbotSite.DoesNotExist:
request.kbsite = None
if not request.kbsite.is_setup:
module = view_func.__module__
allowed = False
for prefix in self.ALLOWED_VIEW_MODULE_PREFIXES:
if module.startswith(prefix):
allowed = True
break
if not allowed:
return SimpleTemplateResponse(
'setup_wizard/setup_required.html',
context=RequestContext(request),
status=403)
return None
def make_result_list(self):
# Get search parameters from the query string.
self.base_queryset = self.queryset()
self.list_queryset = self.get_list_queryset()
self.ordering_field_columns = self.get_ordering_field_columns()
self.paginator = self.get_paginator()
# Get the number of objects, with admin filters applied.
self.result_count = self.paginator.count
self.can_show_all = self.result_count <= self.list_max_show_all
self.multi_page = self.result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and self.can_show_all) or not self.multi_page:
self.result_list = self.list_queryset._clone()
else:
try:
self.result_list = self.paginator.page(self.page_num +
1).object_list
except InvalidPage:
if ERROR_FLAG in self.request.GET.keys():
return SimpleTemplateResponse(
'xadmin/views/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(self.request.path + '?' +
ERROR_FLAG + '=1')
self.has_more = self.result_count > (
self.list_per_page * self.page_num + len(self.result_list))
def activate_user(self, request, uidb64, token):
try:
uid = urlsafe_base64_decode(uidb64)
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and account_activation_token.check_token(
user, token):
self.user_confirmation(user)
return SimpleTemplateResponse(
'acc_activation_succes.html',
context={'front_url': settings.FRONT_MAIN_PAGE},
status=status.HTTP_200_OK)
else:
return SimpleTemplateResponse('acc_activation_error.html',
status=status.HTTP_403_FORBIDDEN)
