def redirect_urlpatterns(): """ Helper function to return a URL pattern for index page http://host/. """ if settings.INDEX_TEMPLATE is None: return patterns('', url(r'^$', never_cache(RedirectView.as_view(url=reverse_lazy('webindex'))), name="index" )) else: return patterns('', url( r'^$', never_cache(RedirectView.as_view(url=reverse_lazy('webindex_custom'))), name="index" ),)
def inner(filename, *args, **kwargs): if not getattr(settings, 'TABULAR_RESPONSE_DEBUG', False): return f(filename, *args, **kwargs) else: resp = never_cache(export_to_debug_html_response)(filename, *args, **kwargs) del resp['Content-Disposition'] # Don't trigger a download return resp
def rest_view(self, view, cacheable=False): """ Decorator to create an rest view attached to this ``RestSite``. You'll want to use this from within ``RestSite.get_urls()``: class MyRestSite(RestSite): def get_urls(self): from django.conf.urls.defaults import patterns, url urls = super(MyRestSite, self).get_urls() urls += patterns('', url(r'^my_view/$', self.rest_view(some_view)) ) return urls By default, rest_views are marked non-cacheable using the ``never_cache`` decorator. If the view can be safely cached, set cacheable=True. """ def inner(request, *args, **kwargs): return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) return update_wrapper(inner, view)
def wrap(view): def wrapper(request, *args, **kwargs): if not self.admin_site.has_permission(request): return self.admin_site.login(request) return view(request, *args, **kwargs) wrapper = never_cache(wrapper) return update_wrapper(wrapper, view)
def admin_staff_member_required( view_func=None, redirect_field_name=REDIRECT_FIELD_NAME, login_url='admin:login', cacheable=False ): """ Decorator for views that checks that the user is logged in and is a staff member, redirecting to the login page if necessary. Also it make csrf_protect for each view and if need mark as chachable """ actual_decorator = user_passes_test( lambda u: u.is_active and u.is_staff, login_url=login_url, redirect_field_name=redirect_field_name ) view_func = actual_decorator(view_func) # make views as non chached if not cacheable: view_func = never_cache(view_func) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view_func, 'csrf_exempt', False): view_func = csrf_protect(view_func) return view_func
def admin_view(self, view, cacheable=False): """Decorator to create an admin view attached to this AdminSite. This wraps the view and provides permission checking by calling self.has_permission (except for the logout page). """ def inner(request, * args, ** kwargs): if not self.has_permission(request) and view != self.logout: if not request.user.is_authenticated(): return self.login(request) else: return render_to_response('shibsso/no_permission.html', { 'title': _('Site administration') }, context_instance=RequestContext(request)) return view(request, * args, ** kwargs) if not cacheable: inner = never_cache(inner) try: # Backwards-compatibility for Django 1.1.1 if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) except: pass return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): """ Override superclass admin_view to provide our own auth flow. Specifically: * Return 403 if authenticated and has_permission returns False * Redirect to login if not authenticated """ def inner(request, *args, **kwargs): if not self.has_permission(request): if request.path == reverse('admin:logout', current_app=self.name): index_path = reverse('admin:index', current_app=self.name) return HttpResponseRedirect(index_path) # Inner import to prevent django.contrib.admin (app) from # importing django.contrib.auth.models.User (unrelated model). from django.contrib.auth.views import redirect_to_login # Begin overriden portion here if not request.user.is_authenticated(): return redirect_to_login( request.get_full_path(), reverse('admin:login', current_app=self.name) ) else: return HttpResponseForbidden(_('Permission Denied.')) # End overriden portion return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): """ Decorator to create an admin view attached to this ``AdminSite``. This wraps the view and provides permission checking by calling ``self.has_permission``. You'll want to use this from within ``AdminSite.get_urls()``: class MyAdminSite(AdminSite): def get_urls(self): from django.conf.urls import patterns, url urls = super(MyAdminSite, self).get_urls() urls += patterns('', url(r'^my_view/$', self.admin_view(some_view)) ) return urls By default, admin_views are marked non-cacheable using the ``never_cache`` decorator. If the view can be safely cached, set cacheable=True. """ def inner(request, *args, **kwargs): if not self.has_permission(request) and getattr(view, 'need_site_permission', True): return self.create_admin_view(self.login_view)(request, *args, **kwargs) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) return update_wrapper(inner, view)
def decorate(view): """ Decorate our views as login_required and never_cache :param view: The view to decorate :return: The view, decorated with login_required and never_cache """ return login_required(never_cache(view))
def as_view(self, view, cacheable=False, extra_permission=None): """ Wraps a view in authentication/caching logic extra_permission can be used to require an extra permission for this view, such as a module permission """ def inner(request, *args, **kwargs): if not self.has_permission(request, extra_permission): # show login pane return self.login(request) return view(request, *args, **kwargs) # Mark it as never_cache if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, "csrf_exempt", False): inner = csrf_protect(inner) inner = ensure_csrf_cookie(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): # not everything can take extra_context excludes = [ 'password_change', 'password_change_done', 'i18n_javascript', 'login', 'logout', 'user_change_password', ] def inner(request, *args, **kwargs): if not self.has_permission(request): return self.login(request) if view.__name__ not in excludes: extra_context = kwargs.get('extra_context', {}) extra_context = self.annotate_context(extra_context) kwargs['extra_context'] = extra_context return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): """ Decorator to create an admin view attached to this ``AdminSite``. This wraps the view and provides permission checking by calling ``self.has_permission``. You'll want to use this from within ``AdminSite.get_urls()``: class MyAdminSite(AdminSite): def get_urls(self): from django.conf.urls.defaults import patterns, url urls = super(MyAdminSite, self).get_urls() urls += patterns('', url(r'^my_view/$', self.admin_view(some_view)) ) return urls By default, admin_views are marked non-cacheable using the ``never_cache`` decorator. If the view can be safely cached, set cacheable=True. """ def inner(request, *args, **kwargs): if not self.has_permission(request): return self.login(request) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def test_shared_cache_control_decorator_keeps_no_cache(rf, settings): request = rf.get('/foo') response = shared_cache_control(never_cache(simple_view))(request) assert response.status_code == 200 assert 'public' not in response['Cache-Control'] assert 's-maxage' not in response['Cache-Control'] assert_no_cache_header(response)
def get_plugin_urls(self): subscription_view = self.get_subscription_view() return patterns('', url( r'^subscribe/$', never_cache(subscription_view), name='aldryn-mailchimp-subscribe'), )
def never_cache_patterns(*args): """Prevent any included URLs from being cached by the browser. It's sometimes desirable not to allow browser caching for a set of URLs. Any URLs passed in will have the :py:func:`~django.views.decorators.cache.never_cache` decorator applied. Args: *args (tuple): The URL arguments to pass to the function. If the first parameter is a prefix string for view lookup strings, then this will emit a deprecation warning, as these are no longer supported in Django 1.10 or higher. Returns: list: A list of URL patterns. """ if isinstance(args[0], six.string_types): prefix = args[0] args = args[1:] else: prefix = None if prefix: msg = ('String prefixes for URLs in never_cache_patterns() is ' 'deprecated, and will not work on Django 1.10 or higher.') if hasattr(RegexURLPattern, 'add_prefix'): warnings.warn(msg, RemovedInDjblets20Warning) else: raise ValueError(msg) pattern_list = [] for t in args: if prefix: if isinstance(t, (list, tuple)): # This will crash on Django 1.10. The user has been warned. t = url(prefix=prefix, *t) elif isinstance(t, RegexURLPattern): # This will crash on Django 1.10. The user has been warned. t.add_prefix(prefix) cb = never_cache(t.callback) if hasattr(t, '_callback'): # Django <= 1.9 t._callback = cb else: # Django >= 1.10 t.callback = cb pattern_list.append(t) return pattern_list
def wrapped_view_func(request, *args, **kwargs): try: (cache_timeout, cache_kwargs) = req_cache_func(request, *args, **kwargs) ret = cache_page(cache_timeout, **cache_kwargs)(view_func) except TypeError: ret = never_cache(view_func) return ret(request, *args, **kwargs)
def get_allow_handler(self): """ When never_cache is truthy, wraps the base handler in django.views.decorators.cache.never_cache(). """ allow = super(NeverCache, self).get_allow_handler() if self.get_never_cache(): allow = cache.never_cache(allow) return allow
def with_perms(self, view, cacheable=False): def inner(request, *args, **kwargs): if not self.has_permission(request): return self.login(request) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def api_view(self, view, cacheable=False): def inner(request, *args, **kwargs): return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): def inner(request, *args, **kwargs): if not self.has_permission(request): raise PermissionDenied return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. inner = csrf_protect(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): def inner(request, *args, **kwargs): if not self.has_permission(request): return self.login(request) for key in kwargs.keys(): if key.startswith(OBJECT_ID_PREFIX): self.base_object_ids.update({key[len(OBJECT_ID_PREFIX):]: kwargs.pop(key)}) if key.startswith(MODEL_ADMIN_PREFIX): self.base_tools_model_admins.update({key[len(MODEL_ADMIN_PREFIX):]: kwargs.pop(key)}) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable=False): """ Decorator to create an admin view attached to this ``AdminSite``. This wraps the view and provides permission checking by calling ``self.has_permission``. You'll want to use this from within ``AdminSite.get_urls()``: class MyAdminSite(AdminSite): def get_urls(self): from django.conf.urls import patterns, url urls = super(MyAdminSite, self).get_urls() urls += patterns('', url(r'^my_view/$', self.admin_view(some_view)) ) return urls By default, admin_views are marked non-cacheable using the ``never_cache`` decorator. If the view can be safely cached, set cacheable=True. """ def inner(request, *args, **kwargs): if not self.has_permission(request): country = get_country_from_url(request.get_full_path()) if request.path == reverse(country+':logout',current_app=self.name): index_path = reverse(country+':index', current_app=self.name) return HttpResponseRedirect(index_path) if not "/password/" in request.path: return self.login(request) else: if "/password/reset/done/" in request.path: return self.pwd_reset_done(request) elif "/password/reset/confirm/complete/" in request.path: return self.pwd_reset_confirm_complete(request) elif "/password/reset/confirm/" in request.path: return self.pwd_reset_confirm(request) else: return self.pwd_reset(request) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def decorator(func): @require_http_methods([method]) @wraps(func) def decorated(request, *args, **kwargs): try: return func(request, *args, **kwargs) except Exception as e: print e raise if cache is False: decorated = never_cache(decorated) if ssl: decorated = require_ssl(decorated) decorated.push = push return decorated
def admin_view(self, view, cacheable=False): """ Override to pass kwargs to self.login so we can pass in URL variables """ def inner(request, *args, **kwargs): if not self.has_permission(request): return self.login(request, *args, **kwargs) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def admin_view(self, view, cacheable = False): def inner(request, *args, **kwargs): if not self.has_permission(request): if request.path == reverse('logout', current_app=self.name): index_path = reverse('index', current_app=self.name) return HttpResponseRedirect(index_path) return self.login(request) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def site_view_decor(self, view, cacheable=False): """ 为所有 View 提供公共装饰,访问权限验证 在Site.get_urls 方法中使用该方法 :param cacheable: 默认情况下,所有的 AdminView 会通过 ``never_cache`` 标记成不做缓存,如果确实需要缓存,可以设置 cacheable=True """ def inner(request, *args, **kwargs): if not self.has_permission(request) and getattr(view, 'need_site_permission', True): # 没有权限则跳转到登录页 return self.create_admin_view(self.login_view)(request, *args, **kwargs) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) return update_wrapper(inner, view)
def admin_view(cls, cached=False, **kwargs): view = func(cls, **kwargs) def has_permission(request): if request.user.is_active: return True else: return False def inner(request, *args, **kwargs): if not has_permission(request) and getattr(cls, 'need_site_permission', True): return LoginView.as_view()(request, *args, **kwargs) return view(request, *args, **kwargs) if not cached: inner = never_cache(inner) return update_wrapper(inner, view)
def wrapp_view(self, meth): def wrapper(request, *args, **kwargs): view = login_required(meth, login_url=reverse('djoe_client:login')) return view(request, *args, **kwargs) if getattr(meth, 'jsonable', False): wrapper = self.json_decor(wrapper) if not getattr(meth, 'cacheable', False): wrapper = never_cache(wrapper) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(meth, 'csrf_exempt', False): wrapper = csrf_protect(wrapper) return wrapper
def admin_view(self, view, cacheable=False): """ Decorator to create an admin view attached to this ``AdminSite``. This wraps the view and provides permission checking by calling ``self.has_permission``. You'll want to use this from within ``AdminSite.get_urls()``: class MyAdminSite(AdminSite): def get_urls(self): from django.conf.urls import url urls = super(MyAdminSite, self).get_urls() urls += [ url(r'^my_view/$', self.admin_view(some_view)) ] return urls By default, admin_views are marked non-cacheable using the ``never_cache`` decorator. If the view can be safely cached, set cacheable=True. """ def inner(request, *args, **kwargs): if not self.has_permission(request): if request.path == reverse('admin:logout', current_app=self.name): index_path = reverse('admin:index', current_app=self.name) return HttpResponseRedirect(index_path) # Inner import to prevent django.contrib.admin (app) from # importing django.contrib.auth.models.User (unrelated model). from django.contrib.auth.views import redirect_to_login return redirect_to_login( request.get_full_path(), reverse('admin:login', current_app=self.name) ) return view(request, *args, **kwargs) if not cacheable: inner = never_cache(inner) # We add csrf_protect here so this function can be used as a utility # function for any view, without having to repeat 'csrf_protect'. if not getattr(view, 'csrf_exempt', False): inner = csrf_protect(inner) return update_wrapper(inner, view)
def never_cache_patterns(prefix, *args): """ Prevents any included URLs from being cached by the browser. It's sometimes desirable not to allow browser caching for a set of URLs. This can be used just like patterns(). """ pattern_list = [] for t in args: if isinstance(t, (list, tuple)): t = url(prefix=prefix, *t) elif isinstance(t, RegexURLPattern): t.add_prefix(prefix) t._callback = never_cache(t.callback) pattern_list.append(t) return pattern_list
from django.core.exceptions import ValidationError from django.core.validators import EmailValidator from django.http import HttpResponse, HttpResponseRedirect from django.views.decorators.cache import never_cache from parliament.accounts.models import LoginToken, TokenError, User from parliament.core.views import disable_on_readonly_db from parliament.utils.views import JSONView class CurrentAccountView(JSONView): def get(self, request): return {'email': request.authenticated_email} current_account = never_cache(CurrentAccountView.as_view()) class LogoutView(JSONView): def post(self, request): request.authenticated_email = None return True logout = never_cache(LogoutView.as_view()) def _get_ip(request): ip = request.META['REMOTE_ADDR'] if ip == '127.0.0.1' and 'HTTP_X_REAL_IP' in request.META: ip = request.META['HTTP_X_REAL_IP']
from stars.apps.institutions.data_displays.views import * app_name = 'data_displays' urlpatterns = [ # data views url(r'^$', TemplateView.as_view( template_name='institutions/data_views/index.html'), name="data_view_index"), url(r'^pie-chart-visualization/$', PieChartView.as_view(), name="piechart"), url(r'^dashboard/$', Dashboard.as_view(), name="dashboard"), url(r'^(?P<cs_version>[^\/]+)/categories/$', never_cache(AggregateFilter.as_view()), name="categories_data_display"), url(r'^(?P<cs_version>[^\/]+)/scores/$', never_cache(ScoreFilter.as_view()), name="scores_data_display"), url(r'^(?P<cs_version>[^\/]+)/content/$', never_cache(ContentFilter.as_view()), name="content_data_display"), url(r'^(?P<cs_version>[^\/]+)/scores/excel/$', never_cache(ScoreExcelFilter.as_view())), url(r'^(?P<cs_version>[^\/]+)/content/excel/$', never_cache(ContentExcelFilter.as_view())), url(r'^callback/cs/(?P<cs_id>\d+)/$', CategoryInCreditSetCallback.as_view()), url(r'^callback/cat/(?P<category_id>\d+)/$', SubcategoryInCategoryCallback.as_view()),
fully_decorated.anything = "Expected __dict__" # django.views.decorators.http fully_decorated = require_http_methods(["GET"])(fully_decorated) fully_decorated = require_GET(fully_decorated) fully_decorated = require_POST(fully_decorated) fully_decorated = require_safe(fully_decorated) # django.views.decorators.vary fully_decorated = vary_on_headers('Accept-language')(fully_decorated) fully_decorated = vary_on_cookie(fully_decorated) # django.views.decorators.cache fully_decorated = cache_page(60 * 15)(fully_decorated) fully_decorated = cache_control(private=True)(fully_decorated) fully_decorated = never_cache(fully_decorated) # django.contrib.auth.decorators # Apply user_passes_test twice to check #9474 fully_decorated = user_passes_test(lambda u: True)(fully_decorated) fully_decorated = login_required(fully_decorated) fully_decorated = permission_required('change_world')(fully_decorated) # django.contrib.admin.views.decorators fully_decorated = staff_member_required(fully_decorated) # django.utils.functional fully_decorated = memoize(fully_decorated, {}, 1) fully_decorated = allow_lazy(fully_decorated) fully_decorated = lazy(fully_decorated)
def delete(self, request, pk): if request.instance.session: return HttpResponse(status=codes.bad_request) request.instance.delete() return HttpResponse(status=codes.no_content) class DataContextHistoryResource(DataContextBase): "DataContext History Resource" def get(self, request): queryset = self.get_queryset(request, archived=True).iterator() return map(self.prepare, queryset) datacontext_resource = never_cache(DataContextResource()) datacontext_history_resource = never_cache(DataContextHistoryResource()) # Resource endpoints urlpatterns = patterns( '', url(r'^$', datacontext_resource, name='datacontexts'), url(r'^session/$', datacontext_resource, {'session': True}, name='datacontext'), url(r'^(?P<pk>\d+)/$', datacontext_resource, name='datacontext'), url(r'^history/$', datacontext_history_resource, name='datacontext-history'), )
""" Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from django.conf.urls import url from django.views.decorators.cache import never_cache from submissions import views urlpatterns = [ # Submissions list url(r'^api/v1/submissions/$', never_cache(views.SubmissionListAPIView.as_view()), name='submissions-list'), # Submissions home (loads Submissions application) url(r'^submissions/', views.SubmissionsHomeView.as_view(), name='submissions-home') ]
re_path(r'^profile/', include('apps.users.urls')), re_path(r'^questions/', include('apps.questions.urls')), re_path(r'^i18n/', include(i18n)), # API urls re_path(r'^api/', include(ct_router.urls)), re_path(r'^api/', include(module_router.urls)), re_path(r'^api/', include(orga_router.urls)), re_path(r'^api/', include(question_router.urls)), re_path(r'^api/', include(likes_router.urls)), re_path(r'^api/', include(router.urls)), re_path(r'^upload/', user_is_project_admin(ck_views.upload), name='ckeditor_upload'), re_path(r'^browse/', never_cache(user_is_project_admin(ck_views.browse)), name='ckeditor_browse'), re_path(r'^components/$', contrib_views.ComponentLibraryView.as_view()), re_path(r'^jsi18n/$', JavaScriptCatalog.as_view(), name='javascript-catalog'), re_path( r'^(?P<organisation_slug>[-\w_]+)/', include([ path( 'budgeting/', include(('apps.budgeting.urls', 'a4_candy_budgeting'), namespace='a4_candy_budgeting')), path('dashboard/', include('apps.dashboard.urls')), path( 'ideas/',
httpcode = 200 announcements = signals.get_announcements.send(sender="login", location="loginpage") announcements = [announcement[1] for announcement in announcements] return HttpResponse(render_to_string( "registration/login.html", { "form": form, "error": error, "next": nextlocation, "annoucements": announcements }, request), status=httpcode) dologin = never_cache(dologin) def dologout(request): """Logout current user.""" if not request.user.is_anonymous: signals.user_logout.send(sender="dologout", request=request) logger = logging.getLogger("modoboa.auth") logger.info( _("User '{}' successfully logged out").format( request.user.username)) logout(request) return HttpResponseRedirect(reverse("core:login")) class PasswordResetView(auth_views.PasswordResetView):
else: form = None return render( request, template, { 'all_super_groups': mgr.get_super_groups(), 'page_class': 'settings', 'title': title, 'settings_group': settings, 'group': group, 'form': form, 'use_db': use_db, }) group_settings = never_cache( permission_required('livesettings.change_setting')(group_settings)) # group_settings = never_cache(admins_only(group_settings)) # Site-wide setting editor is identical, but without a group # permission_required is implied, since it calls group_settings def site_settings(request): return group_settings(request, group=None, template='livesettings/site_settings.html') def export_as_python(request): """Export site settings as a dictionary of dictionaries"""
def staff_nocache(view): return staff_member_required(never_cache(view))
# -*- coding: utf-8 -*- from django.urls import re_path from django.views.decorators.cache import never_cache from django.views.decorators.csrf import ensure_csrf_cookie from eventkit_cloud.auth.views import oauth, callback, logout urlpatterns = [ re_path(r'^oauth$', ensure_csrf_cookie(oauth), name='oauth'), re_path(r'^callback$', ensure_csrf_cookie(callback), name='callback'), re_path(r'^logout$', never_cache(ensure_csrf_cookie(logout)), name='logout') ]
def filebrowser_view(view): "Only let staff browse the files" return staff_member_required(never_cache(xframe_options_sameorigin(view)))
from __future__ import absolute_import import django from django.conf.urls import url from django.contrib.auth.decorators import login_required from django.views.decorators.cache import never_cache from ckeditor_uploader import views if django.VERSION >= (1, 8): urlpatterns = [ url(r'^upload/', login_required(views.upload), name='ckeditor_upload'), url(r'^browse/', never_cache(login_required(views.browse)), name='ckeditor_browse'), ] else: from django.conf.urls import patterns urlpatterns = patterns( '', url(r'^upload/', login_required(views.upload), name='ckeditor_upload'), url(r'^browse/', never_cache(login_required(views.browse)), name='ckeditor_browse'), )
def filebrowser_view(view): "Only let staff browse the files" return staff_member_required(never_cache(view))
The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/3.0/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.urls import include, path 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) """ from django.contrib import admin from django.urls import path, include from django.conf import settings from django.contrib.staticfiles.views import serve from django.views.decorators.cache import never_cache from django.conf.urls.static import static urlpatterns = [ path('admin/', admin.site.urls), path('', include('main.urls', namespace='')), ] if settings.DEBUG: urlpatterns.append(path('static/<path:path>', never_cache(serve))) urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/3.1/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.urls import include, path 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) """ from django.contrib import admin from django.urls import path, include, re_path from django.views.generic import TemplateView from django.views.decorators.cache import never_cache from .auth import google index = never_cache(TemplateView.as_view(template_name='index.html')) urlpatterns = [ path('admin/', admin.site.urls), path('api/', include('api.urls')), path('auth/', include('djoser.urls')), path('auth/', include('djoser.urls.jwt')), path('auth/google', google), re_path(r'^.*', index) ]
{ "dir": path, "p": p, "page": page, "results_var": results_var, "counter": counter, "query": query, "title": _("Media Library"), "settings_var": get_settings_var(), "breadcrumbs": get_breadcrumbs(query, path), "breadcrumbs_title": "", }, ) browse = staff_member_required(never_cache(browse)) # mkdir signals filebrowser_pre_createdir = Signal(providing_args=["path", "dirname"]) filebrowser_post_createdir = Signal(providing_args=["path", "dirname"]) @xframe_options_sameorigin def mkdir(request): """ Make Directory. """ from filebrowser_safe.forms import MakeDirForm
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.conf.urls import url, include 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls')) """ from django.conf.urls import url, include from django.contrib import admin # ref: https://stackoverflow.com/questions/7013735/turn-off-caching-of-static-files-in-django-development-server from django.conf import settings from django.contrib.staticfiles.views import serve as serve_static from django.views.decorators.cache import never_cache from . import views urlpatterns = [ url(r'^$', views.home, name='home'), url(r'^(?P<filename>(robots.txt)|(humans.txt))$', views.home_files, name='home_files'), url(r'^about/$', views.about, name='about'), url(r'^submissions/', views.submissions, name="submissions"), url(r'^ajax_update_ucd', views.ajax_update_ucd, name="ajax_update"), url(r'^ajax_select2', views.ajax_select2, name="ajax_select2"), url(r'^ingredient/', include('flavors.urls')), url(r'^admin/', admin.site.urls), url(r'^select2/', include('django_select2.urls')), url(r'^accounts/', include('allauth.urls')), ] if settings.DEBUG: urlpatterns.append(url(r'^static/(?P<path>.*)$', never_cache(serve_static)))
from django.contrib import admin from django.urls import path, include from django.conf import settings from django.conf.urls.static import static from ckeditor_uploader import views as views_ckeditor from django.views.decorators.cache import never_cache import blog.views import disposal.views import account.views import board.views import market.views urlpatterns = [ path('admin/', admin.site.urls), path('', blog.views.main, name='main'), path('be_geppetto/', include('blog.urls')), path('disposal/', include('disposal.urls')), path('account/', include('account.urls')), path('board/', include('board.urls')), path('ckeditor/', include('ckeditor_uploader.urls')), path('market/', market.views.market, name="market"), path('market/<int:market_id>', market.views.detail4, name="detail4"), path('market/delete/<int:market_id>', market.views.delete4, name="delete4"), path('market/new', market.views.marketpost, name="newblog"), path(r'^upload/', views_ckeditor.upload, name="ckeditor_upload"), path(r'^browse/', never_cache(views_ckeditor.browse), name='ckeditor_browse'), ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
# # You should have received a copy of the Apache License # along with Galaxy. If not, see <http://www.apache.org/licenses/>. from django.conf.urls import url from django.conf import settings from django.views.decorators.cache import never_cache from django.contrib.staticfiles.views import serve as serve_staticfiles from django.views.static import serve as serve_static app_name = 'main' urlpatterns = [] if settings.DEBUG: urlpatterns += [ url(r'^static/(?P<path>.*)$', never_cache(serve_staticfiles)) ] else: urlpatterns += [ url(r'^static/(?P<path>.*)$', serve_static, kwargs={'document_root': settings.STATIC_ROOT}), url(r'^(?P<path>.*(?:css|js|png|jpg|jpeg|ico|woff|woff2|svg|ttf))/?$', serve_static, kwargs={'document_root': settings.STATIC_ROOT}), url(r'^(?!api|static|accounts|{})'.format(settings.ADMIN_URL_PATH), serve_static, kwargs={ 'document_root': settings.STATIC_ROOT, 'path': 'index.html' })
app_name = 'home' urlpatterns = [ # path('', views.index, name='index'), path( "robots.txt", TemplateView.as_view(template_name="robots.txt", content_type="text/plain"), ), path('home/', views.home_view, name='home'), path('about/', views.AboutView.as_view(), name='about'), ] api_urlpatterns = [ path('home/bill-list/', never_cache(views.BillListAPIView.as_view()), name='bill-list'), path('home/bill-titles/<congressnumber>', never_cache(views.BillListTitleAPIView.as_view()), name='bill-titles'), path('home/bill-title/<bill>/', never_cache(views.GetBillTitleAPIView.as_view()), name='bill-title'), path('press-statements/<congress>/<bill_type>/<bill_number>/', never_cache(GetPressStatementsAPIView.as_view()), name='press-statements'), ] urlpatterns += api_urlpatterns
from django.contrib import admin from django.urls import path, include from django.conf import settings from django.conf.urls.static import static from django.contrib.staticfiles.views import serve from django.views.decorators.cache import never_cache urlpatterns = [ path('admin/', admin.site.urls), path('', include('yandex.urls', namespace='yandex')) ] if settings.DEBUG: urlpatterns.append( path('static/<path:path>', never_cache(serve)) ) urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
from django.views.defaults import page_not_found urlpatterns += [ url(r'^404/$', page_not_found, {'exception': None}), ] # Only enable debug toolbar if it's an installed app if apps.is_installed('debug_toolbar'): import debug_toolbar urlpatterns += [ url(r'^__debug__/', include(debug_toolbar.urls)), ] # Serving static/media under debug urlpatterns += static(settings.STATIC_URL, never_cache(staticfiles_serve)) urlpatterns += static(settings.MEDIA_URL, never_cache(serve), document_root=settings.MEDIA_ROOT) def handler500(request, template_name='500.html'): """ 500 handler with request context. """ try: template = loader.get_template(template_name) except TemplateDoesNotExist: return HttpResponseServerError('<h1>Server Error (500)</h1>', content_type='text/html') return HttpResponseServerError(template.render({ 'request': request, }))
'session_key': request.session.session_key, 'result_processor': ASYNC_QUERY_RESULT_PROCESSOR_NAME } job_id = async_get_result_rows( request.instance.context, request.instance.view, query_options, job_data, request=request) return HttpResponseRedirect( reverse('serrano:jobs:single', kwargs={'job_uuid': job_id})) results_resource = never_cache(AsyncQueryResultsResource()) # Resource endpoints urlpatterns = patterns( '', url( r'^(?P<pk>\d+)/results/$', results_resource, name='results' ), url( r'^session/results/$', results_resource, {'session': True}, name='results' ),
path( "api/logs/projects/<slug:project_id>/clusters/<slug:cluster_id>/", include("backend.container_service.observability.log_stream.urls"), ), re_path(r"^api/helm/projects/(?P<project_id>\w{32})/", include("backend.helm.urls")), path(r"change_log/", include("backend.change_log.urls")), # cluster manager的代理请求 url( r"^{}".format(settings.CLUSTER_MANAGER_PROXY["PREFIX_PATH"]), include("backend.container_service.clusters.mgr.proxy.urls"), ), ] # 导入版本特定的urls try: from backend.urls_ext import urlpatterns as urlpatterns_ext urlpatterns += urlpatterns_ext except ImportError: pass # vue urls 需要放到最后面 urlpatterns_vue = [ # fallback to vue view url(r"^login_success.html", never_cache(LoginSuccessView.as_view())), url(r"^(?P<project_code>[\w\-]+)?", never_cache(VueTemplateView.as_view(container_orchestration="k8s"))), ] urlpatterns += urlpatterns_vue
from django.conf.urls import url from django.views.decorators.cache import never_cache from gwells.urls import app_root_slash from . import views urlpatterns = [ # Template views url(r'^well/(?P<pk>[0-9]+)$', views.WellDetailView.as_view(), name='well_detail'), # API endpoints # Well url(r'^api/v1/wells/(?P<well_tag_number>[0-9]+)$', never_cache(views.WellDetail.as_view()), name='well-detail'), # Well tag search url(r'^api/v1/wells/tags/$', never_cache(views.WellTagSearchAPIView.as_view()), name='well-tag-search'), # Documents (well records) url(r'^api/v1/wells/(?P<tag>[0-9]+)/files$', never_cache(views.ListFiles.as_view()), name='file-list'), # Extract files url(r'^api/v1/wells/extracts$', views.ListExtracts.as_view(),
error_message = _('The username or password is incorrect.') else: form = EmailAuthenticationForm(request) request.session.set_test_cookie() if Site._meta.installed: current_site = Site.objects.get_current() else: current_site = RequestSite(request) # For logging in API clients if request.method == "GET" and "api" in request.GET and request.GET[ 'api'] == 'yes': token = get_token(request) return HttpResponse(json.dumps({'csrfmiddlewaretoken': token}), content_type='application/json') return render( request, template_name, { 'form': form, REDIRECT_FIELD_NAME: settings.URL + redirect_to, 'site': current_site, 'site_name': current_site.name, 'allow_registration': settings.ALLOW_REGISTRATION, 'error_message': error_message }) mylogin = never_cache(mylogin)
url(r"^", include("backend.apps.paas_monitor.urls", namespace="paas_monitor")), url(r"^api-auth/", include("rest_framework.urls", namespace="rest_framework")), # BCS K8S special urls url(r"^", include("backend.bcs_k8s.helm.urls", namespace="bcs_k8s_app")), url(r"^", include("backend.bcs_k8s.app.urls", namespace="bcs_k8s_helm")), # Ticket凭证管理 url(r"^", include("backend.apps.ticket.urls", namespace="ticket")), url(r"^", include("backend.bcs_k8s.authtoken.urls", namespace="bcs_authtoken")), url(r"^api/hpa/projects/(?P<project_id>\w{32})/", include("backend.apps.hpa.urls", namespace="hpa")), ] # 导入版本特定的urls try: from backend.urls_bk import urlpatterns as urlpatterns_bk urlpatterns += urlpatterns_bk except ImportError: pass # vue urls 需要放到最后面 urlpatterns_vue = [ # fallback to vue view url(r"^login_success.html", never_cache(LoginSuccessView.as_view())), url(r"^.*$", never_cache(VueTemplateView.as_view())), ] urlpatterns += urlpatterns_vue
from sys import exc_info from traceback import format_exception import logging from django.views.decorators.csrf import csrf_exempt log = logging.getLogger() def pay_ship_info(request): return payship.base_pay_ship_info(request, config_get_group('PAYMENT_PAYPAL'), payship.simple_pay_ship_process_form, 'shop/checkout/paypal/pay_ship.html') pay_ship_info = never_cache(pay_ship_info) def confirm_info(request): payment_module = config_get_group('PAYMENT_PAYPAL') try: order = Order.objects.from_request(request) except Order.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0 and not order.is_partially_paid: template = lookup_template(payment_module, 'shop/checkout/empty_cart.html')
raise serializers.ValidationError( {'error': "Search term 'q' must be set"}) return super(APISearchQueryBackend, self).filter_queryset(request, queryset, view) class APISearchView(SearchView): serializer_class = APIDocumentSerializer renderer_classes = [JSONRenderer] filter_backends = ( APISearchQueryBackend, KeywordQueryBackend, TagGroupFilterBackend, APILanguageFilterBackend, HighlightFilterBackend, ) search = never_cache(APISearchView.as_view()) @waffle_flag('bc-signals') @api_view(['POST']) def bc_signal(request): serializer = BCSignalSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.validated_data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
from django.views.decorators.cache import never_cache from django.contrib.auth.models import User from django.contrib.admin.views.main import ChangeList from django.contrib.admin.models import LogEntry, ADDITION, CHANGE, DELETION from rt_www.photogallery.models import Gallery, Photo, PhotoPlace from rt_www.swimmers.models import Swimmer def index(request): c = Context(request, {'cl': ChangeList(request, Gallery)}) return render_to_response('photogallery/admin/index.html', {}, context_instance=c) index = staff_member_required(never_cache(index)) def change_gallery(request, add=None, gid=None): new_data = errors = {} gallery = None context_args = {'aphotos': Photo.objects.filter(gallery__isnull=True)} if gid: context_args['cphotos'] = Photo.objects.filter( gallery__id__exact=int(gid)) try: context_args['gallery'] = Gallery.objects.get(pk=gid) except Gallery.DoesNotExist: errors.append(_('The Gallery was not found')) if request.POST: