def flatpage(request, url):
"""
Public interface to the flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or :template:`flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
return render_flatpage(request, f)
python类get_current_site()的实例源码
def _send_invitation_mail(request, invitation, subject, template_name):
if not invitation.invitee.email:
return
old_lang = translation.get_language()
translation.activate(invitation.invitee.language)
template = loader.get_template('groups/mail_{0}.txt'.format(template_name))
message = template.render({
'invitation': invitation,
'site': get_current_site(request)
})
translation.activate(old_lang)
send_mail(settings.EMAIL_SUBJECT_PREFIX + subject,
message,
settings.DEFAULT_FROM_EMAIL,
[invitation.invitee.email],
fail_silently=True)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated:
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def get_tenant(request):
if not hasattr(request, '_cached_tenant'):
try:
request._cached_tenant = get_current_site(request).tenant_site.tenant
return request._cached_tenant
except (TenantSite.DoesNotExist, Site.DoesNotExist):
pass
try:
tenant_http_header = 'HTTP_' + get_setting('TENANT_HTTP_HEADER').replace('-', '_').upper()
request._cached_tenant = Tenant.objects.get(slug=request.META[tenant_http_header])
except LookupError:
lazy_tenant = TenantMiddleware.get_current_tenant()
if not lazy_tenant:
return None
lazy_tenant._setup()
request._cached_tenant = lazy_tenant._wrapped
except Tenant.DoesNotExist:
return None
return request._cached_tenant
def flatpage(request, url):
"""
Public interface to the flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or :template:`flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
return render_flatpage(request, f)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated:
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def flatpage(request, url):
"""
Public interface to the flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or :template:`flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
return render_flatpage(request, f)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated:
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def send_email(self, email):
User = get_user_model()
protocol = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "http")
current_site = get_current_site(self.request)
email_qs = EmailAddress.objects.filter(email__iexact=email)
for user in User.objects.filter(pk__in=email_qs.values("user")):
uid = int_to_base36(user.id)
token = self.make_token(user)
password_reset_url = "{0}://{1}{2}".format(
protocol,
current_site.domain,
reverse("account_password_reset_token", kwargs=dict(uidb36=uid, token=token))
)
ctx = {
"user": user,
"current_site": current_site,
"password_reset_url": password_reset_url,
}
hookset.send_password_reset_email([user.email], ctx)
def get_referer_url(request):
"""
?????????? ????????????? ???? REFERER, ???? ?? ? ???????? ?????.
?????, ?????????? MULTILANGUAGE_FALLBACK_URL
"""
referer = request.META.get('HTTP_REFERER')
if not referer:
return resolve_url(options.MULTILANGUAGE_FALLBACK_URL)
site = get_current_site(request)
url_parts = list(urlparse(referer))
if url_parts[1] != site.domain:
return resolve_url(options.MULTILANGUAGE_FALLBACK_URL)
url_parts[0] = ''
url_parts[1] = ''
return urlunparse(url_parts)
def dl_link(context, template='footer/dl_link.html'):
request = context.get('request')
if not request:
return ''
site = get_current_site(request)
website = site.domain
page_info = request.path_info
set_crc = binascii.crc32(('set:%s:%s' % (website, page_info)).encode())
set_names = tuple(sorted(conf.DL_LINKS.keys()))
url_set = conf.DL_LINKS[set_names[set_crc % len(set_names)]]
url_crc = binascii.crc32(('url:%s:%s' % (website, page_info)).encode())
records = tuple(sorted(url_set, key=lambda x: x['url']))
record = records[url_crc % len(url_set)]
return loader.render_to_string(template, record, request=context.get('request'))
def away_links(request, html):
"""
???????? ??? ??????? ?????? ? html-???? ?? ?????? ????? ? ??????????
"""
site = get_current_site(request)
soup = Soup(html, 'html5lib')
for tag in soup.findAll('a'):
if tag.get('href'):
parsed = parse.urlparse(tag['href'])
if '' not in (parsed.scheme, parsed.netloc) \
and not parsed.query \
and not is_same_domain(parsed.netloc, site.domain):
tag['target'] = '_blank'
tag['href'] = resolve_url('away') + '?url=' + parsed.geturl()
if tag.string:
tag.string = parse.unquote(tag.string)
return soup.body.decode_contents()
def away(request):
referer = request.META.get('HTTP_REFERER')
if not referer:
return redirect(settings.LOGIN_REDIRECT_URL)
# ??????????, ??? ? REFERER ???????? ???
referer = urlparse(referer)
if '' in (referer.scheme, referer.netloc):
return redirect(settings.LOGIN_REDIRECT_URL)
# ?????????, ??? ??????? ? ?????? ?????
site = get_current_site(request)
if not is_same_domain(referer.netloc, site.domain):
return redirect(settings.LOGIN_REDIRECT_URL)
url = request.GET.get('url') or resolve_url('index')
return render(request, 'away/away.html', {
'url': url
})
def send(request, receivers, subject, message, fail_silently=True):
if not receivers:
return True
if isinstance(receivers, str):
receivers = [receivers]
# ??????? ?????? ? subject
site = get_current_site(request)
subject = subject.format(domain=site.domain)
plain = strip_tags(message)
plain = re_newline_spaces.sub('\n', plain)
plain = re_newlines.sub('\n\n', plain)
send_mail(
subject=subject,
message=plain,
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=receivers,
html_message=message,
fail_silently=fail_silently,
)
def send_activation_email(request, user):
subject = _('Profile Activation')
from_email = settings.DEFAULT_FROM_EMAIL
current_site = get_current_site(request)
domain = current_site.domain
code = get_random_string(20)
context = {
'domain': domain,
'code': code,
}
act = Activation()
act.code = code
act.user = user
act.save()
html_content = render_to_string('email/activation_profile.html', context=context, request=request)
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [user.email])
msg.attach_alternative(html_content, 'text/html')
msg.send()
def send_activation_change_email(request, user, new_email):
subject = _('Change email')
from_email = settings.DEFAULT_FROM_EMAIL
current_site = get_current_site(request)
domain = current_site.domain
code = get_random_string(20)
context = {
'domain': domain,
'code': code,
}
act = Activation()
act.code = code
act.user = user
act.email = new_email
act.save()
html_content = render_to_string('email/change_email.html', context=context, request=request)
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [user.email])
msg.attach_alternative(html_content, 'text/html')
msg.send()
def send_reset_password_email(request, user):
from_email = settings.DEFAULT_FROM_EMAIL
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
token_generator = default_token_generator
use_https = request.is_secure()
context = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'user': user,
'token': token_generator.make_token(user),
'protocol': 'https' if use_https else 'http',
}
subject = loader.render_to_string('registration/password_reset_subject.txt', context)
subject = ''.join(subject.splitlines())
body = loader.render_to_string('registration/password_reset_email.html', context)
email_message = EmailMultiAlternatives(subject, body, from_email, [user.email])
email_message.send()
def capabilities(request):
"""
The capabilities view is like the about page, but for consumption by code instead of humans.
It serves to provide information about the Exchange instance.
"""
capabilities = {}
capabilities["versions"] = {
'exchange': get_exchange_version(),
'geonode': get_pip_version('GeoNode'),
'geoserver': get_geoserver_version(),
}
mobile_extension_installed = "geonode_anywhere" in settings.INSTALLED_APPS
capabilities["mobile"] = (
mobile_extension_installed and
# check that the OAuth application has been created
len(Application.objects.filter(name='Anywhere')) > 0
)
current_site = get_current_site(request)
capabilities["site_name"] = current_site.name
return JsonResponse({'capabilities': capabilities})
def flatpage(request, url):
"""
Public interface to the flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or :template:`flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
return render_flatpage(request, f)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated:
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def send_invite(modeladmin, request, queryset):
for r in queryset:
if not Invite.objects.filter(request=r).exists():
Invite.objects.create(request=r)
context = {
"site": get_current_site(request).domain,
"invite_link": build_absolute_uri(
None,
"{}?invite={}".format(reverse("account_signup"), r.invite.code)
)
}
send_mail(
"Beta Invite",
message=render_to_string("beta/email/invite.txt", context=context),
html_message=render_to_string("beta/email/invite.html", context=context),
from_email=getattr(settings, "DEFAULT_FROM_EMAIL"),
recipient_list=[r.email]
)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated():
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
def send_email(modeladmin, request, queryset):
our_email = settings.DEFAULT_FROM_EMAIL
users = Subscription.objects.all()
recipients = [user.contact_email for user in users]
messages = []
site = get_current_site(request)
template = get_template('festflow/newsletter.html')
for user in users:
for newsletter in queryset:
content = template.render({
'newsletter': newsletter.content,
'url': 'http://%s/subscribe?unsubscribe=%s' % (
site, user.identifier),
})
messages.append((
"Newsletter",
content,
our_email,
recipients))
send_mass_mail(messages, fail_silently=False)
def flatpage(request, url):
"""
Public interface to the flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or :template:`flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
return render_flatpage(request, f)
def render(self, context):
if 'request' in context:
site_pk = get_current_site(context['request']).pk
else:
site_pk = settings.SITE_ID
flatpages = FlatPage.objects.filter(sites__id=site_pk)
# If a prefix was specified, add a filter
if self.starts_with:
flatpages = flatpages.filter(
url__startswith=self.starts_with.resolve(context))
# If the provided user is not authenticated, or no user
# was provided, filter the list to only public flatpages.
if self.user:
user = self.user.resolve(context)
if not user.is_authenticated:
flatpages = flatpages.filter(registration_required=False)
else:
flatpages = flatpages.filter(registration_required=False)
context[self.context_name] = flatpages
return ''
