def handle_interview_request(request):
"""
sample data format:
{
‘studentId’: 123,
“startDateTime: 2020-06-05T13:00:00’,
“endDateTime”: ‘2020-06-05T14:00:00’,
}
"""
if request.method != "POST":
return HttpResponseNotAllowed(Constants.ERROR_METHOD_NOT_ALLOWED)
try:
student, start, end = parse_req_body(request.body)
except Exception as e:
return HttpResponseBadRequest(e)
interviews = Interview.objects.filter(student=student,toTime__lt=datetime.datetime.now(tz=timezone.utc))\
.order_by("-toTime")[:Constants.MAX_INTERVIEWS_ALLOWED]
total_interviews = interviews.count()
if total_interviews == Constants.MAX_INTERVIEWS_ALLOWED:
return HttpResponseGone(Constants.ERROR_MAX_INTERVIEWS_EXCEEDS)
if total_interviews >= 2 and grade_flunked(
interviews[0]) and grade_flunked(interviews[1]):
return HttpResponseGone(Constants.ERROR_MAX_BAD_INTERVIEWS)
previous_interviewers = []
result = AvailabilitySlot.objects.filter(
fromTime__lte=start, toTime__gte=end).exclude(
trainer__in=interviews.values_list('trainer', flat=True))
if len(result) == 0:
return HttpResponseNotFound(Constants.ERROR_NO_SLOTS)
return JsonResponse(
{"trainer": book_time_slot(result[0], student, start, end)})
def commentlist(request, ctype, oid, cid):
if (request.method != "GET"):
return HttpResponseNotAllowed(["GET"])
if len(oid) > 18 or len(cid) > 18 or len(ctype) > 1 or ctype not in [
"t", "p", "m"
]:
return HttpResponseBadRequest("Incorrect parameter!")
buddy = getMember(request.user.username)
if buddy is None or buddy.status != MemberStatus.PUBLIC:
return HttpResponseForbidden("Access not allowed!")
sugg = getiSuggestion(cid)
if sugg is None:
return HttpResponseNotFound("Suggestion not found!")
if sugg.status != SuggestionStatus.PUBLIC:
return HttpResponseGone("Suggestion not accessible!")
cmnts = sugg.suggestion_comments.filter(
status=CommentStatus.PUBLIC).order_by("-id")
return render(
request, "members/commentlist.html", {
"title": sugg.title,
"theme": sugg.subject.name,
"sid": str(sugg.id),
"mid": buddy.id,
"cmnts": cmnts,
"ctype": ctype,
"oid": oid
})
def serve(self, request, *args, **kwargs):
_, _, path_args = self.resolve_subpage(request.path)
pouvoir = get_object_or_404(Pouvoir, uuid=path_args['uuid'])
if request.method == 'POST':
form = self.get_form(request.POST,
request.FILES,
page=self,
pouvoir=pouvoir)
if form.is_valid():
try:
submission = self.process_form_submission(
request, form, pouvoir)
return self.render_landing_page(request, submission, *args,
**kwargs)
except ClosedScrutin:
return HttpResponseGone("Ce scrutin est fermé.")
else:
form = self.get_form(pouvoir=pouvoir)
context = self.get_context(request)
context['form'] = form
context['deja_vote'] = (self.get_submission_class().objects.filter(
pouvoir=pouvoir, page=self).exists())
return render(request, self.get_template(request), context)
def wrapped(request, *args, **kwargs):
if (hasattr(request.user, 'developer') and not request.user.is_staff
and request.user.developer.is_cabinet_enabled):
return HttpResponseGone(
render_to_string('403.jinja.html', locals(), request=request))
return func(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
product = get_object_or_404(Product, pk=kwargs['pk'])
u = request.user
if (product.user_has_already_bought(u)
or product.user_has_authored(u)) and product.available:
if product.file:
filepath = settings.MEDIA_ROOT + product.file.name
url = self.get_redirect_url(filepath=filepath)
# The below is taken straight from RedirectView.
if url:
if self.permanent:
return HttpResponsePermanentRedirect(url)
else:
return HttpResponseRedirect(url)
else:
logger.warning('Gone: %s',
self.request.path,
extra={
'status_code': 410,
'request': self.request
})
return HttpResponseGone()
else:
raise Http404
else:
raise Http404
def dispatch(self, request, *args, **kwargs):
slug = kwargs['slug']
try:
entity = self.model.objects.get(slug=slug)
except ObjectDoesNotExist:
entity = None
else:
response = super().dispatch(request, *args, **kwargs)
if not entity:
short_slug = '-'.join(slug.split('-')[:-1])
try:
entity = self.model.objects.get(slug__startswith=short_slug)
except (ObjectDoesNotExist, MultipleObjectsReturned):
response = HttpResponseGone()
else:
redirect_url = reverse(entity.endpoint, args=[entity.slug])
response = HttpResponsePermanentRedirect(redirect_url)
return response
def redirect_to(request, url, permanent=True, query_string=False, **kwargs):
"""
Redirect to a given URL.
The given url may contain dict-style string formatting, which will be
interpolated against the params in the URL. For example, to redirect from
``/foo/<id>/`` to ``/bar/<id>/``, you could use the following URLconf::
urlpatterns = patterns('',
('^foo/(?P<id>\d+)/$', 'django.views.generic.simple.redirect_to', {'url' : '/bar/%(id)s/'}),
)
If the given url is ``None``, a HttpResponseGone (410) will be issued.
If the ``permanent`` argument is False, then the response will have a 302
HTTP status code. Otherwise, the status code will be 301.
If the ``query_string`` argument is True, then the GET query string
from the request is appended to the URL.
"""
args = request.META["QUERY_STRING"]
if args and query_string and url is not None:
url = "%s?%s" % (url, args)
if url is not None:
klass = permanent and HttpResponsePermanentRedirect or HttpResponseRedirect
return klass(url % kwargs)
else:
logger.warning('Gone: %s' % request.path,
extra={
'status_code': 410,
'request': request
})
return HttpResponseGone()
def manager_view(request):
manager = attempt_auth(request)
if not manager:
return HttpResponseGone("No session found that relates to current request")
if request.method == 'GET':
# no need for this statement if only intercepting post requests
# return general context for viewport page
return manager.status(request)
if request.method == 'POST':
if request.POST.get('add') is not None:
logger.debug("add found")
target_id = None
if 'target' in request.POST:
target_id = int(request.POST.get('target'))
manager.add_workflow(workflow_type=int(request.POST.get('add')), target_id=target_id)
elif request.POST.get('edit') is not None and request.POST.get('edit_id') is not None:
logger.debug("edit found")
manager.add_workflow(workflow_type=request.POST.get('edit'), edit_object=int(request.POST.get('edit_id')))
elif request.POST.get('cancel') is not None:
if not manager.pop_workflow():
del ManagerTracker.managers[request.session['manager_session']]
return manager.status(request)
def redirect_element_view(request, pk):
obj = get_object_or_404(ElementRedirect, pk=pk)
now = timezone.now()
if now >= obj.expires_at:
return HttpResponseGone("Link has expired.")
form = ConfirmPasswordForm()
if request.method == "POST":
form = ConfirmPasswordForm(request.POST)
if not form.is_valid():
return render(request, "redirect.html", {"form": form})
password = form.cleaned_data["password"]
if password == obj.get_password():
# @TODO: This should be done in an asynch way in a task
# with queue
obj.increase_count()
return HttpResponseRedirect(obj.get_source_url())
else:
form.add_error(None, "Incorect password")
return render(
request,
"redirect.html",
{"form": form},
)
def process_request(request):
path = request.get_full_path()
if not path.endswith('/') and settings.APPEND_SLASH:
path += '/'
redirect = router.get_path(path)
if redirect is not None:
http_code = int(redirect.http_code)
if redirect.new_path == '' or http_code == RedirectCodesEnum.C410:
return HttpResponseGone()
elif http_code == RedirectCodesEnum.C301:
return HttpResponsePermanentRedirect(redirect.new_path)
elif http_code == RedirectCodesEnum.C302:
return HttpResponseRedirect(redirect.new_path)
elif http_code == RedirectCodesEnum.C304:
return HttpResponseNotModified(redirect.new_path)
response = HttpResponseRedirectBase(redirect.new_path)
response.status_code = http_code
return response
try:
full_path_parts = request.get_full_path().split('/')
full_path_parts[1] = ''
full_path = '/'.join(full_path_parts[1:])
seo_page = SEOPage.objects.published().get(url__iexact=full_path)
seo_page.apply_seo_params(request)
except (SEOPage.DoesNotExist, SEOPage.MultipleObjectsReturned):
pass
return None
def get(self, request, *args, **kwargs):
url = None
if 'page_id' in request.GET:
page_id = request.GET['page_id']
try:
page = Page.objects.get(id=page_id)
page.views+=1
page.save()
url = page.url
except:
pass
if url:
if self.permanent:
return http.HttpResponsePermanentRedirect(url)
else:
return HttpResponseRedirect(url)
else:
try:
url = self.get_redirect_url(*args, **kwargs)
return HttpResponseredirect(url)
except:
logger.warning(
'Gone: %s', request.path,
extra={'status_code':410, 'request': request}
)
return HttpResponseGone()
def gone(request, *args, **kwargs):
"""
Display a nice 410 gone page.
"""
t = template.loader.get_template('410.html')
c = template.RequestContext(request, {'request': request})
return HttpResponseGone(t.render(c))
def login(request):
if request.method == 'POST':
# POST
username = request.POST['username']
password = request.POST['password']
try:
next_href = request.GET['next']
except KeyError:
next_href = "/home/%s" % username
u = authenticate(username=username, password=password)
if u is not None:
if u.is_active:
# success
auth_login(request, u)
return redirect(next_href)
else:
# disabled account
return HttpResponseGone('Inactive user.')
else:
# invalid login
return HttpResponseForbidden('Access Denied.')
elif request.method == 'GET':
# GET
try:
next_href = request.GET['next']
except KeyError:
next_href = None
return render(request, 'homes/login.html', {'next_href': next_href})
def broadcast(request, hash, date):
schedule_object = get_object_or_404(
models.EventSchedule.objects.select_related('location',
'location__city',
'liturgy'),
hash=hash)
date = datetime.strptime(date, '%Y-%m-%d').date()
broadcast = queries.get_broadcast(schedule_object, date)
state = queries.get_broadcast_status(schedule_object, date)
if (broadcast):
if (state == queries.BroadcastState.Past):
return HttpResponseGone("Ez a közvetítés már nem elérhető.")
elif (state == queries.BroadcastState.Live
or state == queries.BroadcastState.Recent
or 'mutasd' in request.GET):
return render(request, 'zsolozsma/broadcast_current.html',
{'broadcast': broadcast})
else:
return render(request, 'zsolozsma/broadcast_future.html', {
'broadcast': broadcast,
'state': state
})
raise Http404("Nincs ilyen közvetítés!")
def summary(request):
if request.session.get('form_data'):
return render(request, 'form/summary.html', {
'form_data': request.session['form_data'],
})
else:
return HttpResponseGone("Ooops")
def render_to_response(self, context):
if not self.own_marked_for_deletion:
if "application/json" in (self.request.headers.get("accept"),
self.request.content_type):
# last time it is used
for component_val in context["hierarchy"].values():
component_val["name"] = component_val["ob"].name
component_val["description"] = \
component_val["ob"].description
component_val.pop("ob")
for content_val in component_val["contents"].values():
content_val["name"] = content_val["ob"].name
content_val["description"] = \
content_val["ob"].description
content_val.pop("ob")
response = JsonResponse(context["hierarchy"])
else:
response = super().render_to_response(context)
elif self.request.user.is_authenticated:
# last resort: redirect to index
index = self.request.user.usercomponent_set.get("index")
response = HttpResponsePermanentRedirect("{}?{}".format(
reverse('spider_base:entity-delete',
kwargs={"token": index.token}),
context["sanitized_GET"]))
else:
response = HttpResponseGone()
response["Access-Control-Allow-Origin"] = self.request.get_host()
response["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
return response
def post(self, request, *args, **kwargs):
if self.deserialize(request, *args, **kwargs):
url = self.get_redirect_url(*args, **kwargs)
if url:
return HttpResponseRedirect(url)
else:
return HttpResponseGone()
else:
return self.get(request, *args, **kwargs)
def process_response(self, request, response):
if response.status_code != 404:
return response
url = request.get_full_path()
url_qs = ''
try:
r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
from_url=url)
except Redirect.DoesNotExist:
try:
parsed = urlparse.urlparse(url)
r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
from_url=parsed.path)
url_qs = parsed.query
except (Redirect.DoesNotExist, AttributeError, TypeError):
r = None
if r is None and settings.APPEND_SLASH:
# Try removing the trailing slash.
try:
r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
from_url=url[:url.rfind('/')] +
url[url.rfind('/') + 1:])
except Redirect.DoesNotExist:
pass
if r is not None:
if not any(
[hasattr(r.content_object, 'get_absolute_url'), r.to_url]):
return HttpResponseGone()
if not r.to_url:
# It's a redirect to a content object.
url = r.get_content_object_url()
if not url:
raise Http404
else:
url = r.to_url
np = urlparse.urlparse(url)
new_qs = ((np.query and url_qs) and '?{0}&{1}'.format(np.query, url_qs)) or \
(np.query and '?{0}'.format(np.query)) or \
(url_qs and '?{0}'.format(url_qs)) or \
''
if np.netloc:
url = '{0}://{1}{2}{3}'.format(np.scheme, np.netloc, np.path,
new_qs)
else:
url = '{0}{1}'.format(np.path, new_qs)
return HttpResponsePermanentRedirect(url)
# No redirect was found. Return the response.
return response
def get(self, request):
user = request.user
contracts = user.contract_set.filter(time_end__isnull=True)
if len(contracts) == 0:
return HttpResponseGone("No bike hirerd")
contract = contracts[0]
serializer = serializers.SecretContractSerializer(contract)
print(serializer.data)
return Response(serializer.data)
def django_tests():
from django.http import HttpResponse
from django.http import HttpResponseRedirect, HttpResponsePermanentRedirect, HttpResponseBadRequest, HttpResponseNotModified, HttpResponseNotFound, HttpResponseForbidden, HttpResponseNotAllowed, HttpResponseGone, HttpResponseServerError
response = HttpResponse()
response.set_cookie("C1", "world") # Noncompliant
response.set_cookie("C2", "world", secure=None) # Noncompliant
response.set_cookie("C3", "world", secure=False) # Noncompliant
response.set_cookie("C4", "world", secure=True)
response2 = HttpResponseRedirect()
response2.set_cookie("C5", "world") # Noncompliant
response2.set_cookie("C5", "world", None, None, "/", None, True) # OK
response2.set_signed_cookie("C5", "world") # Noncompliant
response2.set_signed_cookie("C5", "world", secure=True) # OK
response2.set_signed_cookie("C5", "world", other=False, secure=True) # OK
response2.set_signed_cookie("C5", "world", secure=False) # Noncompliant
response2.set_signed_cookie("C5", "world", secure=None) # Noncompliant
response2.set_signed_cookie("C5", "", "world", None, None, "/", None,
True) # OK
kwargs = {secure: True}
response2.set_signed_cookie("C5", "world", **kwargs) # OK
kwargs = {secure: False}
response2.set_signed_cookie("C5", "world", **kwargs) # FN
get_cookie().set_cookie("C3", "world", secure=False)
response3 = HttpResponsePermanentRedirect()
response3.set_cookie("C6", "world") # Noncompliant
response4 = HttpResponseNotModified()
response4.set_cookie("C7", "world") # Noncompliant
response5 = HttpResponseBadRequest()
response5.set_cookie("C8", "world") # Noncompliant
response6 = HttpResponseNotFound()
response6.set_cookie("C9", "world") # Noncompliant
response7 = HttpResponseForbidden()
response7.set_cookie("C10", "world") # Noncompliant
response8 = HttpResponseNotAllowed()
response8.set_cookie("C11", "world") # Noncompliant
response9 = HttpResponseGone()
response9.set_cookie("C12", "world") # Noncompliant
response10 = HttpResponseServerError()
response10.set_cookie("C13", "world") # Noncompliant
def get_thumbnail(request, id):
try:
db_image = DBImage.objects.get(id=id)
thumbnail = db_image.get_thumbnail()
image_data = thumbnail.file.read()
mime_type = thumbnail.mime_type
return HttpResponse(image_data, content_type=mime_type)
except DBImage.DoesNotExist:
raise Http404("Image Not Found")
except IOError:
return HttpResponseGone("Image Moved")
def post(self, request, *args, **kwargs):
self.object = self.get_object()
if self.object.user.is_active:
return HttpResponseGone(_("User is already active"))
invitation_backend().send_reminder(
self.object.user, **{
"domain": get_current_site(self.request),
"organization": self.organization,
"sender": request.user,
})
return redirect(self.get_success_url())
def get(self, request, *args, **kwargs):
url = self.get_redirect_url(*args, **kwargs)
if url:
if self.permanent:
return HttpResponsePermanentRedirect(url)
else:
return HttpResponseRedirect(url)
else:
logger.warning(
"Gone: %s", request.path, extra={"status_code": 410, "request": request}
)
return HttpResponseGone()
def handle_invalid(self,
*,
token,
parse_res,
validity_info,
redirect_url=None):
gone_tpl = self.gone_template_name or self.__class__.gone_template_name
early_tpl = self.early_template_name or self.__class__.early_template_name
try:
valid_from, valid_until = validity_info
except (TypeError, ValueError):
valid_from = valid_until = None
if parse_res == self.EXPIRED_TOKEN:
# Return a 410 response
if gone_tpl is None:
if valid_until is not None:
response_str = _('The token %(token)s expired at '
'%(valid_until)s.') % {
'token': token,
'valid_until': valid_until
}
else: # pragma: nocover
response_str = _('The token %(token)s has expired.') % {
'token': token
}
return HttpResponseGone(response_str)
else:
return render(self.request, gone_tpl, status=410)
elif parse_res == self.NOT_YET_VALID_TOKEN:
# 404 seems to be the most appropriate
# (425 Too Early is specific to another HTTP feature)
if early_tpl is None:
if valid_from is not None:
response_str = _('The token %(token)s is only valid from '
'%(valid_from)s.') % {
'token': token,
'valid_from': valid_from
}
else: # pragma: nocover
response_str = _(
'The token %(token)s is not valid yet.') % {
'token': token
}
return HttpResponseNotFound(response_str)
else:
return render(self.request, early_tpl, status=404)
else:
return super().handle_invalid(token=token,
parse_res=parse_res,
validity_info=validity_info,
redirect_url=redirect_url)
def retrieve(self, request, *args, **kwargs):
""" Return the file instead of meta data """
document = self.get_object()
content_type = Document.content_type_from_filename(document.filename)
# If file doesn't exist anymore, delete it
try:
file_contents = document.file.read()
except TypeError:
document.delete()
return HttpResponseGone('File no longer exists')
return HttpResponse(file_contents, content_type=content_type)
def delete_session(request):
manager = attempt_auth(request)
if not manager:
return HttpResponseGone("No session found that relates to current request")
not_last_workflow, result = manager.pop_workflow()
if not_last_workflow: # this was not the last workflow, so don't redirect away
return JsonResponse({})
else:
del ManagerTracker.managers[request.session['manager_session']]
return JsonResponse(get_redirect_response(result))
def get(self, request, *args, **kwargs): self.object = self.get_object() if self.object: url = self.get_redirect_url(*args, **kwargs) if url: return HttpResponseRedirect(url) else: return HttpResponseGone() ## Never else: return HttpResponseForbidden() ## Never
def get(self, request: object, args: object, kwargs: object) -> object:
url = self.get_redirect_url(*args, **kwargs)
if url:
if self.permanent:
return HttpResponsePermanentRedirect(url)
else:
return HttpResponseRedirect(url)
else:
logger.warning(
'Gone: %s', request.path,
extra={'status_code': 410, 'request': request}
)
return HttpResponseGone()
def dispatch(self, request, *args, **kwargs):
onetimepass = get_object_or_404(OneTimePass, pk=kwargs.get("pk"))
if not onetimepass.is_alive:
return HttpResponseGone("Expired", content_type="text/plain")
if onetimepass.is_rate_limited:
k, v = "Retry-After", onetimepass.retry_after
return HttpResponse(
f"{k}: {v}",
content_type="text/plain",
status=HTTPStatus.TOO_MANY_REQUESTS,
headers={k: v},
)
self.onetimepass = onetimepass
return super().dispatch(request, *args, **kwargs)
def createUser(req):
#Create Account (POST)
userRecord = User()
try:
reqData = myUtils.parseReq(req)
if len(User.objects.filter(username=reqData["username"])):
return HttpResponseBadRequest(
"Received username has already exists.")
userRecord.username = reqData["username"]
userRecord.password = reqData["password"]
userRecord.save()
return HttpResponseGone()
except:
return HttpResponseBadRequest()
def home(request, guid, vsid=None, debug=None):
now = datetime.now(tz=timezone.utc)
if vsid is None:
vsid = "0"
guid = "{%s}" % uuid.UUID(guid)
# Providing z=1 as a query parameter enables custom parameters
enable_custom_queries = request.REQUEST.get("z") == "1"
expired = False
user_agent_vs = None
redirect_url = None
if debug:
# On localhost ip will always be empty unless you've got a setup
# that mirrors production
debug_content = ["ip=%s" % request.META.get("HTTP_X_FORWARDED_FOR", ""), "GUID=%s" % guid]
if enable_custom_queries:
debug_content.append("CustomParameters=%s" % request.META.get("QUERY_STRING"))
guid_redirect = helpers.get_redirect_or_404(guid=guid)
cleaned_guid = helpers.clean_guid(guid_redirect.guid).upper()
analytics = {
"gu": cleaned_guid.lower(),
"ve": "1.0",
"vs": vsid,
"ia": "uk",
"ev": "rd",
"cp": "uk",
"tm": "r",
"mo": 0,
"ua": request.META.get("HTTP_USER_AGENT", ""),
"ip": request.META.get("HTTP_X_REAL_IP", ""),
}
syndication_params = {"request": request, "redirect": guid_redirect, "guid": cleaned_guid, "view_source": vsid}
original_url = guid_redirect.url
if debug:
debug_content.append("RetLink(original)=%s" % guid_redirect.url)
syndication_params["debug_content"] = debug_content
response = helpers.get_syndication_redirect(**syndication_params)
if response is None:
user_agent_vs, response = helpers.get_opengraph_redirect(request, guid_redirect, cleaned_guid)
if response is None:
if vsid == "1604":
# msccn redirect
company_name = guid_redirect.company_name
company_name = helpers.quote_string(company_name)
redirect_url = "http://us.jobs/msccn-referral.asp?gi=" "%s%s&cp=%s" % (cleaned_guid, vsid, company_name)
else:
args = {"request": request, "guid_redirect": guid_redirect, "vsid": vsid, "guid": cleaned_guid}
if debug:
args["debug_content"] = debug_content
returned_dict = helpers.get_redirect_url(**args)
redirect_url = returned_dict.get("redirect_url", "")
facebook = returned_dict.get("facebook", False)
expired = returned_dict.get("expired", False)
browse_url = returned_dict.get("browse_url", "")
if not redirect_url:
redirect_url = guid_redirect.url
params = {"request": request, "url": redirect_url, "exclude": True}
if debug:
debug_content.append("ManipulatedLink(No Manipulation)=%s" % redirect_url)
params["debug_content"] = debug_content
if enable_custom_queries:
redirect_url = helpers.add_custom_queries(**params)
redirect_url = helpers.get_hosted_state_url(guid_redirect, redirect_url)
if debug:
debug_content.append("RetLink=%s" % redirect_url)
if expired:
err = "&jcnlx.err=XIN"
data = {"job": guid_redirect, "expired_url": original_url, "view_source": vsid}
if guid_redirect.buid in [1228, 5480] or 2650 <= guid_redirect.buid <= 2703:
if guid_redirect.buid in [1228, 5480]:
err = "&jcnlx.err=XJC"
else:
err = "&jcnlx.err=XST"
if vsid != "99":
if browse_url:
data["browse_url"] = browse_url
else:
data["browse_url"] = "http://www.my.jobs/%s/careers/" % text.slugify(guid_redirect.company_name)
response = HttpResponseGone(render_to_string("redirect/expired.html", data))
if response is None:
response = HttpResponsePermanentRedirect(redirect_url)
aguid = request.COOKIES.get("aguid") or uuid.uuid4().hex
if "%" in aguid:
aguid = uuid.UUID(unquote(aguid)).hex
myguid = request.COOKIES.get("myguid", "")
analytics.update({"aguid": aguid, "myguid": myguid})
buid = helpers.get_Post_a_Job_buid(guid_redirect)
qs = "jcnlx.ref=%s&jcnlx.url=%s&jcnlx.buid=%s&jcnlx.vsid=%s&jcnlx.aguid=%s&jcnlx.myguid=%s"
qs %= (
helpers.quote_string(request.META.get("HTTP_REFERER", "")),
helpers.quote_string(redirect_url),
buid,
vsid,
aguid,
myguid,
)
if expired:
d_seconds = (now - guid_redirect.expired_date).total_seconds()
d_hours = int(d_seconds / 60 / 60)
qs += "%s&jcnlx.xhr=%s" % (err, d_hours)
response["X-REDIRECT"] = qs
response = helpers.set_aguid_cookie(response, request.get_host(), aguid)
if vsid == "99" or not expired:
# If expired has a value, we're staying on the my.jobs domain and
# showing an expired job page. If not, we're probably going
# to an external site.
parsed = urlparse(redirect_url)
pn = parsed.path
pr = parsed.scheme + ":"
hn = parsed.netloc
se = parsed.query
if se:
se = "?" + se
else:
hn = request.get_host()
pr = "https:" if request.is_secure() else "http:"
pn = request.path
se = request.META.get("QUERY_STRING", "")
if se:
se = "?" + se
# Python doesn't have a method of easily creating a timestamp with
# Zulu at the end. Remove the timezone and append "Z".
now_iso = now.replace(tzinfo=None).isoformat() + "Z"
nv = request.COOKIES.get("de_nv") or now_iso
response.set_cookie("de_nv", nv, expires=30 * 60, domain=request.get_host())
referrer = request.META.get("HTTP_REFERER", "")
analytics.update(
{
# Python tacks microseconds onto the end while JavaScript does
# milliseconds. JS can handle parsing both, as can python-dateutil.
"time": now_iso,
"to": now_iso,
"re": referrer,
"pn": pn,
"pr": pr,
"hn": hn,
"se": se,
"nv": nv,
}
)
response["X-JSON-Header"] = json.dumps(analytics)
if debug and not user_agent_vs:
data = {"debug_content": debug_content}
response = render_to_response("redirect/debug.html", data, context_instance=RequestContext(request))
return response
