def __call__(self, request):
if request.path == '/tutorials/':
return HttpResponsePermanentRedirect('/courses/')
if request.path == '/category/django-blog-tutorial/':
return HttpResponsePermanentRedirect(
'/courses/django-blog-tutorial/')
if request.path.startswith('/post'):
frags = request.path.split('/')
post_id = frags[2]
if post_id == '2':
return HttpResponsePermanentRedirect(
'/courses/django-blog-tutorial/')
with open(
os.path.join(str(environ.Path(__file__) - 1),
'post_material_id_mapping.json'), 'r') as f:
post_material_id_mapping = json.load(f)
if post_id in post_material_id_mapping:
material_id = post_material_id_mapping[post_id]
material = Material.objects.get(pk=material_id)
return redirect(material, permanent=True)
response = self.get_response(request)
return response
def fotoforum_clanek(self, request, response):
comment_id = request.GET.get('clanek')
if comment_id:
naction = request.GET.get('NACTION')
if naction is None:
path = reverse('comment-detail', args=(comment_id, ))
response = HttpResponsePermanentRedirect(path)
elif naction == 'thread':
path = reverse('comment-thread', args=(comment_id, ))
response = HttpResponsePermanentRedirect(path)
return response
def login(request):
if (request.method == 'POST'):
email = request.POST.get('email')
password = request.POST.get('password')
try:
user = User.objects.get(email=email, password=password)
request.session['user_email'] = user.email
request.session['user_password'] = user.password
return HttpResponsePermanentRedirect(
'/accounts/' + user.email[:user.email.find('@')])
except:
return HttpResponsePermanentRedirect('/')
elif (request.method == 'GET'):
return render(request, 'login.html')
def fotoforum_archiv(self, request, response):
q = request.GET.get('hledej')
if request.GET.get('NACTION') == 'find' and q:
path = reverse('comment-archive', kwargs={'action': 'archive'})
qs = urlencode({'q': q}, doseq=True)
response = HttpResponsePermanentRedirect('{}?{}'.format(path, qs))
return response
def _redirect2_https(self, request, secure):
newurl = "https://{}{}".format(request.get_host(), request.get_full_path())
if request.method == 'POST':
raise GenericServiceError(u"Can not redirect to https in POST method. Make call with https")
logger.debug("redirecting request to %s", newurl)
return HttpResponsePermanentRedirect(newurl)
def fotogalerie_fotky(self, request, response):
month = request.GET.get('mesic')
section = request.GET.get('tema')
if not month and not section:
path = reverse('photos-listing-time')
response = HttpResponsePermanentRedirect(path)
elif month and not section:
path = reverse('photos-listing-month', kwargs={'month': month})
response = HttpResponsePermanentRedirect(path)
elif not month and section:
if section == '1':
path = reverse('photos-listing-no-section')
else:
path = reverse('photos-listing-section',
kwargs={'section': section})
response = HttpResponsePermanentRedirect(path)
return response
def get(self, request, *args, **kwargs):
self.object = obj = self.get_object()
correct_url = reverse('parties:detail', args=[obj.slug, obj.pk])
if request.path != correct_url:
return HttpResponsePermanentRedirect(correct_url)
context = self.get_context_data(object=obj)
return self.render_to_response(context)
def get(self, request, *args, **kwargs):
if request.get_host() != get_anchor_domain():
return HttpResponsePermanentRedirect(
redirect_to=urljoin(
get_anchor_domain(), request.get_full_path()
)
)
return super().get(request, *args, **kwargs)
def book(request, flight_id):
if request.method == "POST":
# TODO error checking
flight = Flight.objects.get(pk=flight_id)
passenger = Passenger.objects.get(pk=int(request.POST["passenger"]))
passenger.flights.add(flight)
return HttpResponsePermanentRedirect(
reverse("flight", args=(flight.id, )))
def __call__(self, request):
response = self.get_response(request)
if response.status_code == 200 and request.method == 'GET' and request.resolver_match and request.resolver_match.view_name in HTTPS_VIEW_NAMES and request.scheme == 'http' and not settings.DEBUG:
uri = request.build_absolute_uri(request.get_full_path())
if uri.startswith('http://'):
uri = 'https://' + uri[7:]
return HttpResponsePermanentRedirect(uri)
return response
def process_request(self, request):
host = request.get_host()
# redirect www.foo.com to foo.com?
if settings.STRIP_WWW and host.startswith("www."):
redirect_url = '%s://%s%s' % (request.scheme, host[4:],
request.get_full_path())
return HttpResponsePermanentRedirect(redirect_url)
def fotogalerie_komentare(self, request, response):
username = request.GET.get('autor')
if username:
path = reverse('photos-listing-comments-user',
kwargs={'user': username})
else:
path = reverse('photos-listing-comments')
return HttpResponsePermanentRedirect(path)
def single_composer(request, pComposerSlug):
"""
Show details of a single composer
"""
try:
lPerson = Person.objects.filter(old_composer_slug=pComposerSlug)[0]
except IndexError:
raise Http404
return HttpResponsePermanentRedirect("/people/%s/" % lPerson.slug)
def single_adjudicator(request, pAdjudicatorSlug):
"""
Show details for a single adjudicator
"""
try:
lPerson = Person.objects.filter(
old_adjudicator_slug=pAdjudicatorSlug)[0]
except IndexError:
raise Http404
return HttpResponsePermanentRedirect("/people/%s/" % lPerson.slug)
def fotoforum(self, request, response):
naction = request.GET.get('NACTION')
if not naction or naction == 'clanky':
path = reverse('comment-time')
response = HttpResponsePermanentRedirect(path)
elif naction == 'temata':
path = reverse('comment-themes')
response = HttpResponsePermanentRedirect(path)
elif naction == 'den':
day = request.GET.get('den')
if not day:
day = timezone.now().strftime('%Y-%m-%d')
path = reverse('comment-date', kwargs={'date': day})
response = HttpResponsePermanentRedirect(path)
elif naction == 'author':
username = request.GET.get('author')
if username:
path = reverse('comment-user', kwargs={'user': username})
response = HttpResponsePermanentRedirect(path)
return response
def redirect(self, url=None, message=None, *args, **kwargs):
url = self.get_redirect_url(url, *args, **kwargs)
if url:
if message:
self.set_message(message)
if self.permanent:
return HttpResponsePermanentRedirect(url)
else:
return HttpResponseRedirect(url)
else:
return HttpResponseGone()
def angular_reverse(request, *args, **kwargs):
url_name = request.GET.get('djng_url_name')
url_args = request.GET.getlist('djng_url_args', None)
url_kwargs = {}
prefix = 'djng_url_kwarg_'
for param in request.GET:
if param.startswith(prefix):
url_kwargs[param[len(prefix):]] = request.GET[param]
url = reverse(url_name, args=url_args, kwargs=url_kwargs)
return HttpResponsePermanentRedirect(url)
def get(self, request, *args, **kwargs):
try:
return super().get(request, *args, **kwargs)
except Http404:
# if not found, check for a match on a past PGPID
doc = Document.objects.filter(
old_pgpids__contains=[self.kwargs["pk"]]).first()
# if found, redirect to the correct url for this view
if doc:
self.kwargs["pk"] = doc.pk
return HttpResponsePermanentRedirect(self.get_absolute_url())
# otherwise, continue raising the 404
raise
def _show_single_conductor_page(request,
pConductorSlug,
pContestFilterSlug=None,
pGroupFilterSlug=None,
pFilterTagSlug=None):
"""
Show single conductor page
"""
try:
lPerson = Person.objects.filter(old_conductor_slug=pConductorSlug)[0]
except IndexError:
raise Http404
return HttpResponsePermanentRedirect("/people/%s/" % lPerson.slug)
def process_request(self, request):
"""
Redirects all unslashed paths that match the SLASHED_PATHS setting to their slashed version.
Redirects all slashed paths that don't match the SLASHED_PATHS setting to their slashless version.
"""
# For some dumb reason, str.startswith() ONLY accepts tuples of strings.
# Thus, we cast to tuple to allow our users to use any sequence type for SLASHED_PATHS.
slashed_paths = tuple(getattr(settings, 'SLASHED_PATHS', []))
if request.path.startswith(
slashed_paths) and not request.path.endswith('/'):
# Redirect to slashed versions.
url = request.path + '/'
if request.GET:
url += '?{}'.format(urlencode(request.GET, True))
return HttpResponsePermanentRedirect(url)
elif (not request.path.startswith(slashed_paths)
and request.path.endswith('/') and not request.path == '/'):
# Redirect to unslashed versions.
url = request.path[:-1]
if request.GET:
url += '?{}'.format(urlencode(request.GET, True))
return HttpResponsePermanentRedirect(url)
def create_lot(request):
if request.user.profile.is_manager() or request.user.profile.is_supervisor(
):
params = request.POST
lot_name = params['lotName']
lot_address = params['lotAddress']
new_lot = ParkingLot(name=lot_name,
address=lot_address,
owner=request.user)
new_lot.save()
return HttpResponsePermanentRedirect(f"/assign_areas?lot={new_lot.pk}")
return redirect("genie:index")
def dispatch(self, request, *args, **kwargs):
"""
Base class view for all HTML views.
A fair bit is happening here. The WebPageWrapperView parses a url request, like '/shows',
calculates the API endpoint that web request corresponds to, e.g. 'shows.json', issues a GET
to that url, loads the received JSON and passes that data to the template.
It also appends a slug to the resulting url if needed, for SEO purposes.
"""
try:
if 'favicon.ico' in self.request.path:
return HttpResponse(200)
resolver_match = resolve(self.get_api_url(*args, **kwargs),
self.url_namespace)
except Resolver404:
raise Http404
resolved_url_name = resolver_match.url_name
if resolved_url_name in REDIRECT_NEEDED_URL_PATTERNS and not kwargs.get(
'page_slug'):
redirect_url = get_slug_redirect(request.path)
if redirect_url:
return HttpResponsePermanentRedirect(
redirect_url) # uses a 301 instead of 302 code
response = resolver_match.func(request, *resolver_match.args,
**resolver_match.kwargs)
if response.status_code >= 400:
return response
# working solution
if isinstance(response, TemplateResponse):
response.render()
self.page_data = json.loads(response.content.decode())
for widget in self.page_data.get('widgets', []):
template_name = "widgets/{}.html".format(widget['type'])
try:
get_template(template_name)
except TemplateDoesNotExist:
pass
else:
widget['template_name'] = template_name
return super(WebPageWrapperView,
self).dispatch(request, *args, **kwargs)
def to_djangoresponse(self):
"""django用のレスポンス.
"""
content_type = self.__headers.get('content-type', 'text/plain')
self.set_header('content-length', str(len(self.__body)))
django_response = DjangoHttpResponse(self.__body, content_type=content_type, status=self.status)
for k, v in self.__headers.items():
django_response[k] = v
if self.status == 301:
django_response = HttpResponsePermanentRedirect(django_response.get('location'))
elif self.status == 302:
django_response = HttpResponseRedirect(django_response.get('location'))
for k, arr in self.__cookies.items():
v, expires, domain = arr
django_response.set_cookie(k, v, expires=expires, domain=domain)
return django_response
def __call__(self, request):
# Code to be executed for each request before
# the view (and later middleware) are called.
host = request.get_host()
# redirect www.foo.com to foo.com?
if settings.STRIP_WWW and host.startswith("www."):
redirect_url = '%s://%s%s' % (request.scheme, host[4:],
request.get_full_path())
return HttpResponsePermanentRedirect(redirect_url)
response = self.get_response(request)
# Code to be executed for each request/response after
# the view is called.
return response
def post(self, request):
if request.FILES:
try:
code = ''.join(random.sample(string.digits, 10))
for each in request.FILES.getlist('file'):
NepDiskFile.objects.create(
file=each,
name_display=each.name,
code=code,
owner=request.user,
upload_ip=request.META['REMOTE_ADDR'])
return HttpResponsePermanentRedirect("/disk/s/" + code)
except Exception as any_exec:
print(repr(any_exec))
return HttpResponseRedirect("/disk/home/")
else:
return HttpResponse("not file")
def node(request, node_id=None, allowed_hidden_classes=None):
"""
Gets node by ID or by request path
Optionally pass a list of models which are allowed to be shown in spite of being set up as hidden
"""
language = get_language()
if not node_id:
url = request.path_info[1:]
q = Q(url_alias__exact=url)
if url.endswith("/"):
q |= Q(url_alias__exact=url.strip("/"))
else:
q |= Q(url_alias__exact=url + "/")
node = get_object_or_404(Node, q, language=language, published=True)
if node.url_alias != url:
args = request.META.get('QUERY_STRING', '')
if args:
node.url_alias += "?%s" % args
domain = settings.LANGUAGE_SETTINGS[language]["redirect_to"]
return HttpResponsePermanentRedirect(domain + "/" + node.url_alias)
else:
node = get_object_or_404(Node, id=node_id, language=language)
node = node.as_leaf_class()
if node.hide and (allowed_hidden_classes is None or type(node) not in allowed_hidden_classes):
raise Http404()
if not node.public_access:
if not request.user.is_authenticated():
return redirect('auth_login')
if not node.has_access(request.user):
return HttpResponseForbidden()
if hasattr(node, "check_access") and not node.check_access(request.user):
return HttpResponseForbidden()
if request.is_ajax():
return HttpResponse(node.render())
context = {'node': node}
context.update(node.get_context_values())
return render_to_response(node.get_template_name(request), context,
context_instance=RequestContext(request))
def delete_area(request):
if request.user.profile.is_manager() or request.user.profile.is_supervisor(
):
params = request.GET
if "area" in params:
area_id = int(unquote(params["area"]))
area = LotArea.objects.get(pk=area_id)
if request.user == area.parkingLot.owner:
reservations = Reservation.objects.filter(lotArea=area).all()
if not reservations:
area.delete()
else:
messages.error(
request,
f"Cannot delete area {area.areaIdentifier}. Reservations for this area have already been made.",
"error")
return HttpResponsePermanentRedirect(
f"/assign_areas?lot={area.parkingLot.pk}")
return redirect("genie:index")
def process_request(self, request):
"""
Set request.site to the Site object responsible for handling this request. Wagtail's version of this
middleware only looks at the Sites' hostnames. Ours must also consider the Sites' lists of aliases.
This middleware also denies access to users who have valid accounts, but aren't members of the current Site.
"""
try:
match_type, request.site = match_site_to_request(request)
except Site.DoesNotExist:
try:
hostname = request.META['HTTP_HOST'].split(':')[0]
except KeyError:
hostname = None
logger.warning('site.does_not_exist', hostname=hostname)
request.site = None
except MissingHostException:
# If no hostname was specified, we return a 400 error. This should really only happen during tests.
return HttpResponseBadRequest()
else:
# When a user visits an admin page via an alias or a non-https URL, we need to redirect them to the https
# version of the Site's canonical domain (so the SSL cert will work).
if request.path.startswith('/admin/') and (
match_type == 'alias' or not request.is_secure()):
url = 'https://{}{}'.format(request.site.hostname,
request.path)
if request.GET:
url += '?{}'.format(urlencode(request.GET, True))
return HttpResponsePermanentRedirect(url)
# Non-superusers are not allowed to be logged in to Sites they aren't members of.
# This will NOT log them out of any site besides request.site.
if (not request.user.is_anonymous and not request.user.is_superuser
and
not user_is_member_of_site(request.user, request.site)):
messages.error(request, 'Invalid credentials.')
logger.warning('auth.site.browse.user_not_member',
username=request.user.username,
site=request.site.hostname)
logout(request)
def signup(request):
if (request.method == 'POST'):
email = request.POST.get('email')
password = request.POST.get('password')
#print "{0} - {1}".format(email, password)
user = User(email=email, password=password)
user.save()
res = "A user saved to db\n"
res += "Email: {} \n".format(user.email)
res += "Password: {} \n".format(user.password)
res += "Date: {} \n".format(user.date_modified)
print res
request.session['user_email'] = user.email
request.session['user_password'] = user.password
return HttpResponsePermanentRedirect('/accounts/' +
user.email[:user.email.find('@')])
elif (request.method == 'GET'):
return render(request, 'signup.html')
def update_area(request):
if request.user.profile.is_manager() or request.user.profile.is_supervisor(
):
params = request.POST
if "area" in request.GET:
area_pk = int(unquote(request.GET["area"]))
area = LotArea.objects.get(pk=area_pk)
if request.user == area.parkingLot.owner:
area_id = unquote(params["area"])
capacity = unquote(params["capacity"])
type = unquote(params["type"])
price = float(unquote(params["price"]))
area.areaIdentifier = area_id
area.capacity = capacity
area.type = type
area.price = price
area.save()
return HttpResponsePermanentRedirect(
f"/assign_areas?lot={area.parkingLot.pk}")
return redirect("genie:index")