def get_response(wsgi_request):
'''
Given a WSGI request, makes a call to a corresponding view
function and returns the response.
'''
service_start_time = datetime.now()
# Get the view / handler for this request
view, args, kwargs = resolve(wsgi_request.path_info)
kwargs.update({"request": wsgi_request})
# Let the view do his task.
try:
resp = view(*args, **kwargs)
except Exception as exc:
resp = HttpResponseServerError(content=exc.message)
headers = dict(resp._headers.values())
# Convert HTTP response into simple dict type.
d_resp = {"status_code": resp.status_code, "reason_phrase": resp.reason_phrase,
"headers": headers}
try:
d_resp.update({"body": resp.content})
except ContentNotRenderedError:
resp.render()
d_resp.update({"body": resp.content})
# Check if we need to send across the duration header.
if _settings.ADD_DURATION_HEADER:
d_resp['headers'].update({_settings.DURATION_HEADER_NAME: (datetime.now() - service_start_time).seconds})
return d_resp
def get_response(wsgi_request):
'''
Given a WSGI request, makes a call to a corresponding view
function and returns the response.
'''
# Get the view / handler for this request
view, args, kwargs = resolve(wsgi_request.path_info)
kwargs.update({"request": wsgi_request})
# Let the view do his task.
try:
resp = view(*args, **kwargs)
except Exception as exc:
resp = HttpResponseServerError(content=exc.message)
headers = dict(resp._headers.values())
# Convert HTTP response into simple dict type.
d_resp = {"status_code": resp.status_code, "reason_phrase": resp.reason_phrase,
"headers": headers}
try:
d_resp.update({"body": resp.content})
except ContentNotRenderedError:
resp.render()
d_resp.update({"body": resp.content})
return d_resp
def get(self, request, *args, **kwargs):
"""
If no form already, and we have a form class, construct one with no input.
This can get invoked from .post() if the submitted form was not valid, so
if there's already a form from that, don't clobber it.
"""
if not self.request.user.has_perm('help_desk.add_case'):
return HttpResponseForbidden(
"User %s does not have permission help_desk.add_case" %
self.request.user)
if self.screen:
# make sure we're in the right view
if self.screen.name != self.name:
messages.info(
request, _('Redirecting to current screen for this case.'))
return redirect(reverse(self.screen.name, args=[self.case.pk]))
else:
return HttpResponseServerError("Case has no current screen")
if self.form_class and not getattr(self, 'form', None):
self.form = self.form_class()
return super(ScreenView, self).get(request, *args, **kwargs)
def layer_panel(request, bbox=None):
if request.method != 'GET':
return HttpResponseBadRequest()
try:
sections = AnalysisCreateView.options_panel_dict(bbox=bbox)
form = AnalysisCreationForm(
user=request.user,
exposure_layer=retrieve_layers('exposure', bbox=bbox)[0],
hazard_layer=retrieve_layers('hazard', bbox=bbox)[0],
impact_functions=Analysis.impact_function_list())
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return render(request, "geosafe/analysis/options_panel.html", context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def analysis_json(request, analysis_id):
"""Return the status of an analysis
:param request:
:param analysis_id:
:return:
"""
if request.method != 'GET':
return HttpResponseBadRequest()
try:
analysis = Analysis.objects.get(id=analysis_id)
retval = {
'analysis_id': analysis_id,
'impact_layer_id': analysis.impact_layer_id
}
return HttpResponse(json.dumps(retval),
content_type="application/json")
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def submit_sms(request):
if request.method == 'POST':
try:
print(request.body)
data_string = request.body.decode('utf-8')
data = json.loads(data_string)
data['action'] = 'new_sms'
data['sms'] = strip_tags(data['sms'])
sms = SMSModel.objects.create(number=data['number'],
content=strip_tags(data['sms']))
sms.save()
data['id'] = sms.id
data['date_time'] = datetime.strftime(
sms.date_time, '%b %d, %Y, %I:%M %p').replace(' 0', '')
data_string = json.dumps(data)
new_sms_notification(data_string)
except JSONDecodeError:
return JsonResponse({'status': 'ko'})
return JsonResponse({'status': 'ok'})
else:
return HttpResponseServerError("Error : post request only!")
def accept_updated_tos(request):
""" A bare-bones ajax endpoint to save a user's accepted ToS settings and newsletter settings.
The frontend doesn't care about a return values, so we don't either
(on fail, the user will just see another popup on next request). """
if request.method != 'POST':
return HttpResponseNotAllowed('POST')
if not request.user.is_authenticated:
return HttpResponseForbidden('Must be logged in!')
cosinnus_profile = request.user.cosinnus_profile
form = TermsOfServiceFormFields(request.POST)
if form.is_valid():
# set the newsletter opt-in
if settings.COSINNUS_USERPROFILE_ENABLE_NEWSLETTER_OPT_IN:
cosinnus_profile.settings['newsletter_opt_in'] = form.cleaned_data.get('newsletter_opt_in')
# set the user's tos_accepted flag to true and date to now
accept_user_tos_for_portal(request.user, profile=cosinnus_profile, save=True)
return HttpResponse('Ok')
else:
logger.warning('Could not save a user\'s updated ToS settings.', extra={'errors': form.errors, 'post-data': request.POST})
return HttpResponseServerError('Failed')
def post(request):
try:
stix_title = request.POST['stix_title']
stix_description = request.POST['stix_description']
if not stix_title:
stix_title = 'default'
if not stix_description:
stix_description = stix_title
tlp = request.POST['stix_tlp'].upper()
confirm_data = None
if 'confirm_data' in request.POST:
if request.POST['confirm_data']:
confirm_data = json.loads(request.POST['confirm_data'])
upload(request, stix_title, stix_description, tlp, confirm_data)
return HttpResponse()
except Exception as e:
import traceback
traceback.print_exc()
return HttpResponseServerError(reason=str(e))
def restore_lesson(request):
u"""
Функция для восстановления отмененых занятий
args:
request django.http.request.HttpRequest
return:
django.http.response.HttpResponse
"""
try:
data = json.loads(request.body)
date = datetime.strptime(data["date"], "%d.%m.%Y")
group = data['group']
restore_lesson_func(group, date)
students = get_students(data['group'])
students_lessons = get_students_lessons(data['group'],
date.replace(day=1), None,
students)
ordered = sorted(students_lessons.keys(),
key=lambda s: (s.last_name, s.first_name))
lessons_json = [{
'info':
st.__json__("id", "last_name", "first_name", "phone", "org"),
'lessons': [
l.__json__("group_pass__color", "group_pass__pass_type__id",
"group_pass__pass_type__lessons",
"group_pass__pass_type__prise", "status")
for l in students_lessons[st]
]
} for st in ordered]
return HttpResponse(json.dumps(lessons_json))
except Exception:
return HttpResponseServerError(format_exc())
def rw_flood_frequency(request, hazard_levels_string=None):
hazard_level = [1, 2, 3, 4]
if hazard_levels_string:
hazard_level = [int(v) for v in hazard_levels_string.split(',') if v]
try:
features = []
boundaries = Boundary.objects.filter(
flood_event__hazard_data__in=hazard_level).annotate(
flood_count=Count('id')
)
for boundary in boundaries:
flood_count = boundary.flood_count
if flood_count == 0:
continue
parent_name = None
if boundary.parent:
parent_name = boundary.parent.name
prop = {
'name': boundary.name,
'parent_name': parent_name,
'flood_count': flood_count
}
feat = {
'id': boundary.id,
'type': 'Feature',
'geometry': json.loads(boundary.geometry.geojson),
'properties': prop
}
features.append(feat)
# rows += row
# f.write(json.dumps(rows))
feature_collection = {
'type': 'FeatureCollection',
'features': features
}
return JsonResponse(feature_collection)
except Exception as e:
LOGGER.info(e)
return HttpResponseServerError()
def selling_page_2(request, tx_id):
"""
If a selling transaction has been started, this view will display an address and
request the details necessary from the user for the chosen payment processor
:param request:
:param tx_id:
:return:
"""
# get the transaction from the passed id
tx = get_object_or_404(Transactions, id=tx_id)
# get the payment_processor name from the tx
payment_processor = None
for pp in globs.PAYMENT_PROCESSORS:
if pp[0] == tx.payment_processor:
payment_processor = pp[1]
if payment_processor is None:
return HttpResponseServerError()
if request.method == 'POST':
form = globals()[payment_processor](request.POST)
if form.is_valid():
if payment_processor == 'OKPay':
# check their wallet exists
# get our balance
# alert if amount we can buy is less than the amount they want to sell
# display address for coins to be sent to
# wait for received tx
# initiate payment through OKPay
pass
pass
else:
form = globals()[payment_processor]()
context = {
'form': form,
'payment_processor': payment_processor
}
return render(request, 'butter/selling-page-2.html', context)
def get_response(wsgi_request):
'''
Given a WSGI request, makes a call to a corresponding view
function and returns the response.
'''
resp = None
service_start_time = datetime.now()
# Get the view / handler for this request
try:
view, args, kwargs = resolve(wsgi_request.path_info)
except Resolver404:
resp = HttpResponseNotFound()
if resp is None:
kwargs.update({"request": wsgi_request})
# Let the view do his task.
try:
resp = view(*args, **kwargs)
except Exception as exc:
resp = HttpResponseServerError(content=str(exc))
if hasattr(resp, '_headers'):
headers = {k: v for k, v in six.itervalues(resp._headers)},
else:
headers = {k: v for k, v in resp.headers.items()}
# Convert HTTP response into simple dict type.
d_resp = {
"status_code": resp.status_code,
"reason_phrase": handle_sub_reason_phrase(resp),
"headers": headers,
"body": handle_sub_response_body(resp),
}
# Check if we need to send across the duration header.
if _settings.ADD_DURATION_HEADER:
add_duration_header(d_resp, service_start_time, datetime.now())
return d_resp
def move_lessons(request):
u"""
Функция для переноса занятий у выбранного ученика
args:
request django.http.request.HttpRequest
return:
django.http.response.HttpResponse
"""
try:
data = json.loads(request.body)
print data
lessons = (dict(group_pass_id=l['gpid'],
old_date=datetime.strptime(l['old_date'], '%d%m%Y'),
new_date=datetime.strptime(l['new_date'], '%d%m%Y'))
for l in data['lessons'])
move_lessons_func(lessons)
return HttpResponse()
except Exception:
return HttpResponseServerError(format_exc())
def post(request: HttpRequest, **kwargs) -> HttpResponse:
log.debug(f'Bot Engine Webhook; Request content={request.body};')
im_hash = kwargs.get('hash', '')
try:
messenger = Messenger.objects.get(hash=im_hash)
answer = messenger.dispatch(request)
if answer is not None:
answer = json.dumps(answer).encode('utf-8')
content_type = 'application/json'
log.debug(f'Bot Engine Webhook; Response={answer};')
else:
answer, content_type = b'', None
except Messenger.DoesNotExist as err:
log.exception(f'Bot Engine Webhook; Messenger not found; '
f'Hash={im_hash}; Error={err};')
return HttpResponseNotFound('Webhook not found.')
except Exception as err:
log.exception(f'Bot Engine Webhook; Hash={im_hash}; Error={err};')
return HttpResponseServerError('Server error.')
return HttpResponse(answer, content_type=content_type)
def cancel_commission(request):
if not is_market_opening():
return HttpResponseServerError(u'已闭市,请在开始时操作')
commission_ids = request.POST.get('cancel_list')
commission_ids = json.loads(commission_ids)
if commission_ids:
for commission_id in commission_ids:
if commission_id['type'] == u'buy':
commission = CommissionBuy.objects.filter(
id=commission_id['id']).first()
if commission:
commission.status = 4
commission.save()
cancel_commission_change(commission)
elif commission_id['type'] == u'sale':
commission = CommissionSale.objects.filter(
id=commission_id['id']).first()
if commission:
commission.status = 4
commission.save()
cancel_commission_change(commission)
return HttpResponse('ok')
def layer_archive(request, layer_id):
"""request to get layer's zipped archive"""
if request.method != 'GET':
return HttpResponseBadRequest()
if not layer_id:
return HttpResponseBadRequest()
try:
layer = Layer.objects.get(id=layer_id)
tmp = tempfile.mktemp()
with ZipFile(tmp, mode='w') as zf:
for layer_file in layer.upload_session.layerfile_set.all():
base_name = os.path.basename(layer_file.file.name)
zf.writestr(base_name, layer_file.file.read())
with open(tmp) as f:
return HttpResponse(f.read(), content_type='application/zip')
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def video_poster(request, video_id):
if request.method == 'GET':
second = request.GET.get('second', None)
try:
second = int(second)
except:
return HttpResponseServerError
hours = second / 3600
second -= hours * 3600
minutes = second / 60
second -= minutes * 60
time = "%02d:%02d:%02d" % (hours, minutes, second)
source_url = request.META.get('HTTP_REFERER', None)
video = Video.objects.get(pk=video_id)
get_video_thumb(video.video_original.path,
video.poster.path,
time_s=time)
response = {"url": video.poster.url}
return HttpResponse(json.dumps(response), mimetype="application/json")
else:
return HttpResponseServerError()
def layer_list(request, layer_purpose, layer_category=None, bbox=None):
if request.method != 'GET':
return HttpResponseBadRequest()
if not layer_purpose:
return HttpResponseBadRequest()
try:
layers_object, _ = retrieve_layers(layer_purpose, layer_category, bbox)
layers = []
for l in layers_object:
layer_obj = dict()
layer_obj['id'] = l.id
layer_obj['name'] = l.name
layers.append(layer_obj)
return HttpResponse(json.dumps(layers),
content_type="application/json")
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def send_email_reply(request):
# Save this email in the database.
emailLog = EmailLog()
emailLog.subject = request.POST.get('reply_subject')
emailLog.body = request.POST.get('reply_body')
emailLog.from_email = request.POST.get('reply_from')
emailLog.to = request.POST.get('reply_to')
emailLog.cc = request.POST.get('reply_cc')
reply_department_id = request.POST.get('department_id')
reply_department = Department.objects.get(pk=reply_department_id)
emailLog.department = reply_department
emailLog.timestamp = timezone.now()
emailLog.sent_successfully = False
emailLog.save()
# Send the message.
email_message = EmailMessage()
email_message.subject = emailLog.subject
email_message.body = emailLog.body
email_message.from_email = emailLog.from_email
if emailLog.to:
email_message.to = emailLog.to.split(',')
if emailLog.cc:
email_message.cc = emailLog.cc.split(',')
try:
email_message.send()
emailLog.sent_successfully = True
emailLog.save()
return HttpResponse()
except:
logger.exception("Error sending email. from_email=" +
str(emailLog.from_email) + ", to_department=" +
str(emailLog.department) + ", subject=" +
str(emailLog.subject))
return HttpResponseServerError()
def user_upload_job_poll(request, domain, download_id, template="users/mobile/partials/user_upload_status.html"):
try:
context = get_download_context(download_id)
except TaskFailedError:
return HttpResponseServerError()
context.update({
'on_complete_short': _('Bulk upload complete.'),
'on_complete_long': _('Mobile Worker upload has finished'),
})
class _BulkUploadResponseWrapper(object):
def __init__(self, context):
results = context.get('result') or defaultdict(lambda: [])
self.response_rows = results['rows']
self.response_errors = results['errors']
self.problem_rows = [r for r in self.response_rows if r['flag'] not in ('updated', 'created')]
def success_count(self):
return len(self.response_rows) - len(self.problem_rows)
def has_errors(self):
return bool(self.response_errors or self.problem_rows)
def errors(self):
errors = []
for row in self.problem_rows:
if row['flag'] == 'missing-data':
errors.append(_('A row with no username was skipped'))
else:
errors.append('{username}: {flag}'.format(**row))
errors.extend(self.response_errors)
return errors
context['result'] = _BulkUploadResponseWrapper(context)
return render(request, template, context)
def submit_image(request):
if request.method == 'POST':
try:
data = request.FILES['media'].read()
write_image(data)
message = {
'action': 'display_image',
'image': base64.b64encode(data).decode('utf8')
}
channel_layer = get_channel_layer()
async_to_sync(channel_layer.group_send)('display', {
'type': 'websocket.send',
'text': json.dumps(message)
})
except Exception as e:
print(e)
return JsonResponse({'status': 'ko'})
return JsonResponse({'status': 'ok'})
else:
return HttpResponseServerError("Error : post request only!")
def get(self, request):
"""实现邮箱验证逻辑"""
# 接收参数
token = request.GET.get('token')
# 校验参数：判断token是否为空和过期，提取user
if not token:
return HttpResponseBadRequest('缺少token')
user = check_verify_email_token(token)
if not user:
return HttpResponseForbidden('无效的token')
# 修改email_active的值为True
try:
user.email_active = True
user.save()
except Exception as e:
logger.error(e)
return HttpResponseServerError('激活邮件失败')
# 返回邮箱验证结果
return redirect(reverse('users:info'))
def sign_in(request):
try:
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
logger.info('user %s login ' % username)
login(request, user)
return HttpResponse(json.dumps({'username': user.username}),
content_type="application/json")
else:
logger.warning('user %s is not active ' % username)
return HttpResponseUnauthorized(json.dumps({'detail': 'user is not active'}),
content_type="application/json")
else:
return HttpResponseUnauthorized(json.dumps({'detail': 'username or password error'}),
content_type="application/json")
except BaseException as e:
logger.exception(e)
return HttpResponseServerError(json.dumps({'detail': e}), content_type="application/json")
def get(self, request, *args, **kwargs):
if 'error' in request.GET:
return HttpResponseServerError(self.request.GET['error'])
if 'code' not in self.request.GET and 'state' not in self.request.GET:
return HttpResponseBadRequest(content='Code or State is empty')
if self.request.GET['state'] != self.request.session['openid_state']:
return HttpResponseBadRequest(content='State invalid')
nonce = cache.get(self.request.GET['state'])
if not nonce:
return HttpResponseBadRequest(content='State failure')
user = authenticate(request=self.request,
code=self.request.GET['code'],
redirect_uri=nonce.redirect_uri)
cache.delete(str(nonce.state))
if not user:
return HttpResponseBadRequest(content='Authenticate user failed')
login(self.request, user)
post_openid_login_success.send(sender=self.__class__,
user=user,
request=self.request)
return HttpResponseRedirect(nonce.next_path or '/')
def get_report(request):
if 'what' in request.GET:
this_what = request.GET['what']
report_detail = Student.objects.exclude(
college_number__in=Document.objects.filter(type__exact=this_what).values_list('student', flat=True)
)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="report.csv"'
writer = csv.writer(response, delimiter=str(u';'), dialect='excel')
writer.writerow([
u"شماره دانشجویی".encode('utf8'), u"کد ملی".encode('utf8'), u"نام".encode('utf8'),
u"نام خانوادگی".encode('utf8'), u"رشته".encode('utf8'), u"مقطع".encode('utf8'), u"دوره".encode('utf8'),
])
for i in report_detail:
if Student.objects.filter(college_number=int(i.college_number)).exists():
writer.writerow([
i.college_number, i.social_number.encode('utf8'), i.first_name.encode('utf8'),
i.last_name.encode('utf8'), i.subject.name.encode('utf8'), i.section.name.encode('utf8'),
i.period.encode('utf8')
])
return response
else:
return HttpResponseServerError("Error")
def toggle_analysis_saved(request, analysis_id):
"""Toggle the state of keep of analysis
:param request:
:param analysis_id:
:return:
"""
if request.method != 'POST':
return HttpResponseBadRequest()
try:
analysis = Analysis.objects.get(id=analysis_id)
analysis.keep = not analysis.keep
analysis.save()
return HttpResponse(json.dumps({
'success': True,
'is_saved': analysis.keep,
}),
content_type='application/json')
# return HttpResponseRedirect(reverse('geosafe:analysis-list'))
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def saml_metadata(request):
if "social_core.backends.saml.SAMLAuth" not in settings.AUTHENTICATION_BACKENDS:
raise Http404
# Generate configuration
settings.SOCIAL_AUTH_SAML_SP_ENTITY_ID = get_site_url(
reverse("social:saml-metadata")
)
settings.SOCIAL_AUTH_SAML_ORG_INFO = {
"en-US": {
"name": "weblate",
"displayname": settings.SITE_TITLE,
"url": get_site_url("/"),
}
}
admin_contact = {
"givenName": settings.ADMINS[0][0],
"emailAddress": settings.ADMINS[0][1],
}
settings.SOCIAL_AUTH_SAML_TECHNICAL_CONTACT = admin_contact
settings.SOCIAL_AUTH_SAML_SUPPORT_CONTACT = admin_contact
# Generate metadata
complete_url = reverse("social:complete", args=("saml",))
saml_backend = social_django.utils.load_backend(
load_strategy(request), "saml", complete_url
)
metadata, errors = saml_backend.generate_metadata_xml()
# Handle errors
if errors:
report_error(
level="error", cause="SAML metadata", extra_data={"errors": errors}
)
return HttpResponseServerError(content=", ".join(errors))
return HttpResponse(content=metadata, content_type="text/xml")
def action_download_invitation(request):
"""
Serve a page with invitation URL as an HTML download.
"""
userId = request.session[IntroView.PLAYER_IN_SESSION]
checkIn = PlayerCheckIn.FACILITIES[userId]
try:
defaultPort = None
if settings.EXTERNAL_URL_PREFIX_ is None:
# TODO: set `defaultPort` to None when it equals standard port for the protocol
defaultPort = request.META['SERVER_PORT']
else:
defaultPort = connect.parse_netloc(
settings.EXTERNAL_URL_PREFIX_[1])[1]
seat = int(request.GET['seat'])
if 0 == seat or 0 != checkIn.tokens[userId]:
log = logging.getLogger(IntroView.__module__)
log.error(
'Unauthorized invitation page request from' +
' user id "%s" for seat %d', userId, seat)
return HttpResponseForbidden()
contextVars = {
'URLPrefix': IntroView.getURLPrefix(request, checkIn,
defaultPort),
'token': checkIn.getId(seat)
}
response = render(request, 'durak/invitation.html', contextVars)
response['Content-Disposition'] = (
'attachment; filename="player%d.html"' % (seat + 1))
return response
except:
log = logging.getLogger(type(self).__module__)
log.error('Error serving invitation page for seat "%d"',
request.GET.get('seat'),
exc_info=True)
return HttpResponseServerError()
def get(self, *args, **kwargs):
request = self.request
if 'error' in request.GET:
return HttpResponseServerError(request.GET['error'])
if 'code' not in request.GET and 'state' not in request.GET:
return HttpResponseBadRequest()
if 'oidc_state' not in request.session \
or request.GET['state'] != request.session['oidc_state']:
# Missing or incorrect state; login again.
return HttpResponseRedirect(reverse('keycloak_login'))
nonce = Nonce.objects.get(state=request.GET['state'])
user = authenticate(request=request,
code=request.GET['code'],
redirect_uri=nonce.redirect_uri)
login(request, user)
nonce.delete()
return HttpResponseRedirect(nonce.next_path or '/')
def process_exception(self, request, exception):
if self.test_usability(request) is False:
return
exc_type, exc_value, tb = sys.exc_info()
# If we're getting an exception that does not match the most recent caught one
# we'll be unable to handle it, since we require the traceback.
if type(exception) is not exc_type:
return None
reporter = InteractiveExceptionReporter(request, exc_type, exc_value,
tb)
self.frames = reporter.collect_frames()
if request.is_ajax():
output = reporter.get_traceback_text()
mimetype = 'text/plain'
else:
output = reporter.get_traceback_html()
mimetype = 'text/html'
return HttpResponseServerError(output, content_type=mimetype)
def cancel_analysis(request, analysis_id=None):
if request.method != 'POST':
return HttpResponseBadRequest()
if not analysis_id:
analysis_id = request.POST.get('analysis_id')
if not analysis_id:
return HttpResponseBadRequest()
try:
analysis = Analysis.objects.get(id=analysis_id)
result = analysis.get_task_result()
try:
# to cancel celery task, do revoke
result.revoke(terminate=True)
except BaseException:
# in case result is an empty task id
pass
analysis.delete()
return HttpResponseRedirect(reverse('geosafe:analysis-list'))
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def server_error(request, template_name='500.html'):
if request.is_ajax():
return JRM.render_to_json_response(code=500, messages=_('Server error'))
else:
template = loader.get_template(template_name)
return HttpResponseServerError(template.render({'site': cache.get('site')}))
