text
stringlengths 0
1.05M
| meta
dict |
|---|---|
from functools import wraps
from django.http import Http404
from django.contrib.auth.models import User
from repository.models import Repository
from git.repo import Repo
def require_existing_repo(func):
"""
Checks to see if requested repository is available on user's deposit.
Raises 404 if not.
"""
@wraps(func)
def _decorator(request, *args, **kwargs):
try:
user = User.objects.get(username=kwargs['username'])
repo = Repository.objects.get(owner=user, name=kwargs['repository'])
return func(request, *args, **kwargs)
except:
raise Http404()
return _decorator
def require_existing_rev(func):
"""
Checks to see if requested revision exists in repository.
Raises 404 if not.
"""
@wraps(func)
def _decorator(request, *args, **kwargs):
try:
repo = Repo(Repo.get_repository_location(kwargs['username'], kwargs['repository']))
branches = repo.get_branches()
if 'rev' not in kwargs or kwargs['rev'] in branches + ['HEAD']:
return func(request, *args, **kwargs)
else:
raise Http404()
except:
raise Http404()
return _decorator
def require_access(func):
"""
Checks to see if requesting user has access to repository. If repository
is private then only it's owner has access to it. If not, then everyone
can see or clone this repository.
Raises 404 if not.
"""
@wraps(func)
def _decorator(request, *args, **kwargs):
try:
user = User.objects.get(username=kwargs['username'])
repo = Repository.objects.get(owner=user, name=kwargs['repository'])
if repo.private and request.user.id != user.id:
raise Http404()
else:
return func(request, *args, **kwargs)
except:
raise Http404()
return _decorator
def require_owner_access(func):
"""
Only allows actions on repository if requesting user is repository owner.
For example for getting access to repository settings.
Raises 404 if not.
"""
@wraps(func)
def _decorator(request, *args, **kwargs):
if request.user.username != kwargs['username']:
raise Http404()
else:
return func(request, *args, **kwargs)
return _decorator
def require_valid_readme(func):
"""
Checks to see if requested README is a valid text README file.
Raises 404 if not.
"""
@wraps(func)
def _decorator(request, *args, **kwargs):
if request.path_info.endswith('README.md') or request.path_info.endswith('README.rst'):
return func(request, *args, **kwargs)
else:
raise Http404()
return _decorator
| {
"repo_name": "Djacket/djacket",
"path": "core/backend/repository/decorators.py",
"copies": "1",
"size": "2902",
"license": "mit",
"hash": 3152629704294879000,
"line_mean": 28.9175257732,
"line_max": 95,
"alpha_frac": 0.5920055134,
"autogenerated": false,
"ratio": 4.403641881638847,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5495647395038846,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import Http404
from django.shortcuts import redirect, reverse
from applications.models import Event, Period, EventApplication
from userprofile.models import User
def study_group_application(func):
@wraps(func)
def decorated(req, **kwargs):
try:
group_id = kwargs.get('group_id')
username = kwargs.get('username')
if username is None:
user = req.user
else:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Http404
if group_id is None:
period_id = kwargs.get('period_id')
period = Period.objects.get(id=period_id)
else:
group = Event.objects.get(id=group_id)
period = group.period
f = EventApplication.objects.filter(user=user, event__type=Event.CLASS_GROUP, event__period=period)
if f.exists():
return redirect(reverse('applications_group_application', args=[f.get().id]))
except:
pass
return func(req, **kwargs)
return decorated | {
"repo_name": "CSchool/SchoolSite",
"path": "CSchoolSite/applications/decorators.py",
"copies": "1",
"size": "1220",
"license": "apache-2.0",
"hash": 5019149937220498000,
"line_mean": 33.8857142857,
"line_max": 111,
"alpha_frac": 0.5745901639,
"autogenerated": false,
"ratio": 4.552238805970149,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5626828969870149,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import Http404
from django.utils.decorators import available_attrs
from django.core.urlresolvers import reverse, NoReverseMatch
from django.shortcuts import redirect
from waffle import flag_is_active, switch_is_active
def waffle_flag(flag_name, redirect_to=None):
def decorator(view):
@wraps(view, assigned=available_attrs(view))
def _wrapped_view(request, *args, **kwargs):
if flag_name.startswith('!'):
active = not flag_is_active(request, flag_name[1:])
else:
active = flag_is_active(request, flag_name)
if not active:
response_to_redirect_to = get_response_to_redirect(redirect_to)
if response_to_redirect_to:
return response_to_redirect_to
else:
raise Http404
return view(request, *args, **kwargs)
return _wrapped_view
return decorator
def waffle_switch(switch_name, redirect_to=None):
def decorator(view):
@wraps(view, assigned=available_attrs(view))
def _wrapped_view(request, *args, **kwargs):
if switch_name.startswith('!'):
active = not switch_is_active(switch_name[1:])
else:
active = switch_is_active(switch_name)
if not active:
response_to_redirect_to = get_response_to_redirect(redirect_to)
if response_to_redirect_to:
return response_to_redirect_to
else:
raise Http404
return view(request, *args, **kwargs)
return _wrapped_view
return decorator
def get_response_to_redirect(view):
try:
return redirect(reverse(view)) if view else None
except NoReverseMatch:
return None
| {
"repo_name": "crccheck/django-waffle",
"path": "waffle/decorators.py",
"copies": "1",
"size": "1867",
"license": "bsd-3-clause",
"hash": -6211141240905511000,
"line_mean": 31.1896551724,
"line_max": 79,
"alpha_frac": 0.5977504017,
"autogenerated": false,
"ratio": 4.282110091743119,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5379860493443119,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import Http404
from django.utils.decorators import available_attrs
from waffle import flag_is_active, switch_is_active
def waffle_flag(flag_name):
def decorator(view):
@wraps(view, assigned=available_attrs(view))
def _wrapped_view(request, *args, **kwargs):
if flag_name.startswith('!'):
active = not flag_is_active(request, flag_name[1:])
else:
active = flag_is_active(request, flag_name)
if not active:
raise Http404
return view(request, *args, **kwargs)
return _wrapped_view
return decorator
def waffle_switch(switch_name):
def decorator(view):
@wraps(view, assigned=available_attrs(view))
def _wrapped_view(request, *args, **kwargs):
if switch_name.startswith('!'):
active = not switch_is_active(request, switch_name[1:])
else:
active = switch_is_active(request, switch_name)
if not active:
raise Http404
return view(request, *args, **kwargs)
return _wrapped_view
return decorator
| {
"repo_name": "ilanbm/django-waffle",
"path": "waffle/decorators.py",
"copies": "2",
"size": "1194",
"license": "bsd-3-clause",
"hash": 6143908819002699000,
"line_mean": 30.4210526316,
"line_max": 71,
"alpha_frac": 0.594639866,
"autogenerated": false,
"ratio": 4.131487889273356,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5726127755273356,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpRequest
from django.middleware.cache import CacheMiddleware
from django.utils.cache import add_never_cache_headers, patch_cache_control
from django.utils.decorators import decorator_from_middleware_with_args
def cache_page(timeout, *, cache=None, key_prefix=None):
"""
Decorator for views that tries getting the page from the cache and
populates the cache if the page isn't in the cache yet.
The cache is keyed by the URL and some data from the headers.
Additionally there is the key prefix that is used to distinguish different
cache areas in a multi-site setup. You could use the
get_current_site().domain, for example, as that is unique across a Django
project.
Additionally, all headers from the response's Vary header will be taken
into account on caching -- just like the middleware does.
"""
return decorator_from_middleware_with_args(CacheMiddleware)(
page_timeout=timeout, cache_alias=cache, key_prefix=key_prefix,
)
def cache_control(**kwargs):
def _cache_controller(viewfunc):
@wraps(viewfunc)
def _cache_controlled(request, *args, **kw):
if not isinstance(request, HttpRequest):
raise TypeError(
"cache_control didn't receive an HttpRequest. If you are "
"decorating a classmethod, be sure to use "
"@method_decorator."
)
response = viewfunc(request, *args, **kw)
patch_cache_control(response, **kwargs)
return response
return _cache_controlled
return _cache_controller
def never_cache(view_func):
"""
Decorator that adds headers to a response so that it will never be cached.
"""
@wraps(view_func)
def _wrapped_view_func(request, *args, **kwargs):
if not isinstance(request, HttpRequest):
raise TypeError(
"never_cache didn't receive an HttpRequest. If you are "
"decorating a classmethod, be sure to use @method_decorator."
)
response = view_func(request, *args, **kwargs)
add_never_cache_headers(response)
return response
return _wrapped_view_func
| {
"repo_name": "freakboy3742/django",
"path": "django/views/decorators/cache.py",
"copies": "15",
"size": "2272",
"license": "bsd-3-clause",
"hash": -1093650366277413000,
"line_mean": 37.5084745763,
"line_max": 78,
"alpha_frac": 0.6593309859,
"autogenerated": false,
"ratio": 4.42023346303502,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 59
} |
from functools import wraps
from django.http import HttpResponseForbidden
from django.core.exceptions import ImproperlyConfigured
from .endpoints import Server
from .oauth2_validators import OAuth2Validator
from .oauth2_backends import OAuthLibCore
from .settings import oauth2_settings
def protected_resource(scopes=None, validator_cls=OAuth2Validator, server_cls=Server):
"""
Decorator to protect views by providing OAuth2 authentication out of the box, optionally with
scope handling.
@protected_resource()
def my_view(request):
# An access token is required to get here...
# ...
pass
"""
_scopes = scopes or []
def decorator(view_func):
@wraps(view_func)
def _validate(request, *args, **kwargs):
validator = validator_cls()
core = OAuthLibCore(server_cls(validator))
valid, oauthlib_req = core.verify_request(request, scopes=_scopes)
if valid:
request.resource_owner = oauthlib_req.user
return view_func(request, *args, **kwargs)
return HttpResponseForbidden()
return _validate
return decorator
def rw_protected_resource(scopes=None, validator_cls=OAuth2Validator, server_cls=Server):
"""
Decorator to protect views by providing OAuth2 authentication and read/write scopes out of the
box.
GET, HEAD, OPTIONS http methods require "read" scope. Otherwise "write" scope is required.
@rw_protected_resource()
def my_view(request):
# If this is a POST, you have to provide 'write' scope to get here...
# ...
pass
"""
_scopes = scopes or []
def decorator(view_func):
@wraps(view_func)
def _validate(request, *args, **kwargs):
# Check if provided scopes are acceptable
provided_scopes = oauth2_settings._SCOPES
read_write_scopes = [oauth2_settings.READ_SCOPE, oauth2_settings.WRITE_SCOPE]
if not set(read_write_scopes).issubset(set(provided_scopes)):
raise ImproperlyConfigured(
"rw_protected_resource decorator requires following scopes {0}"
" to be in OAUTH2_PROVIDER['SCOPES'] list in settings".format(
read_write_scopes)
)
# Check if method is safe
if request.method.upper() in ['GET', 'HEAD', 'OPTIONS']:
_scopes.append(oauth2_settings.READ_SCOPE)
else:
_scopes.append(oauth2_settings.WRITE_SCOPE)
# proceed with validation
validator = validator_cls()
core = OAuthLibCore(server_cls(validator))
valid, oauthlib_req = core.verify_request(request, scopes=_scopes)
if valid:
request.resource_owner = oauthlib_req.user
return view_func(request, *args, **kwargs)
return HttpResponseForbidden()
return _validate
return decorator
| {
"repo_name": "vmalavolta/django-oauth-toolkit",
"path": "oauth2_provider/decorators.py",
"copies": "1",
"size": "3060",
"license": "bsd-2-clause",
"hash": -835289865141208300,
"line_mean": 35.4285714286,
"line_max": 98,
"alpha_frac": 0.6160130719,
"autogenerated": false,
"ratio": 4.553571428571429,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.566958450047143,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpResponseForbidden
from ratelimit.backends.cachebe import CacheBackend
def _method_match(request, method=None):
if method is None:
method = ['GET', 'POST', 'PUT', 'DELETE', 'HEAD']
if not isinstance(method, list):
method = [method]
return request.method in method
_PERIODS = {
's': 1,
'm': 60,
'h': 60 * 60,
'd': 24 * 60 * 60,
}
def _split_rate(rate):
count, period = rate.split('/')
count = int(count)
return count, _PERIODS[period.lower()]
_backend = CacheBackend()
def ratelimit(ip=True, block=False, method=None, field=None, rate='5/m'):
def decorator(fn):
count, period = _split_rate(rate)
@wraps(fn)
def _wrapped(request, *args, **kw):
if _method_match(request, method):
_backend.count(request, ip, field, period)
if _backend.limit(request, ip, field, count):
if block:
return HttpResponseForbidden()
request.limited = True
return fn(request, *args, **kw)
return _wrapped
return decorator
| {
"repo_name": "haoqili/MozSecWorld",
"path": "vendor-local/packages/django-ratelimit/ratelimit/decorators.py",
"copies": "1",
"size": "1178",
"license": "bsd-3-clause",
"hash": 6072709293204948000,
"line_mean": 24.6086956522,
"line_max": 73,
"alpha_frac": 0.5772495756,
"autogenerated": false,
"ratio": 3.763578274760383,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9835107026561756,
"avg_score": 0.0011441647597254005,
"num_lines": 46
} |
from functools import wraps
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseBadRequest
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.core.urlresolvers import reverse, resolve
from django.views.decorators.csrf import csrf_exempt
from atlas.utils import locate
from atlas.forms import SelectLocationForm
def location_required(func=None, override_old=False):
'''
This decorator tries to geolocate the client and adds the location
to the session data. If the client cannot be geolocated it redirects
to a 'select-location' page.
'''
def decorator(func):
def inner_decorator(request, *args, **kwargs):
if 'location' in request.session and not override_old:
return func(request, *args, **kwargs)
else:
locate(request)
if 'location' in request.session:
return func(request, *args, **kwargs)
origin = getattr(resolve(request.get_full_path()), 'url_name', None)
return HttpResponseRedirect("%s%s" % (reverse('select-location'),
('?view=%s' % origin) if origin else ''))
return wraps(func)(inner_decorator)
if func:
return decorator(func)
return decorator
@csrf_exempt
def set_location(request):
# force the location to be overridden
if 'location' in request.session:
del request.session['location']
locate(request)
if 'location' in request.session:
return HttpResponse(str(request.session['location']['city']))
if 'REMOTE_ADDR' in request.META:
if 'atlas_id' in request.COOKIES:
return HttpResponseBadRequest('Client cannot be located using IP %s and location %s' %
(request.META['REMOTE_ADDR'], request.COOKIES['atlas_id']))
return HttpResponseBadRequest('Client cannot be located using IP %s' %
request.META['REMOTE_ADDR'])
elif 'atlas_id' in request.COOKIES:
return HttpResponseBadRequest('Client cannot be located using location %s' %
request.COOKIES['atlas_id'])
return HttpResponseBadRequest('Client cannot be located without IP or location cookie')
def select_location(request, form_class=SelectLocationForm):
if request.method == 'POST':
form = form_class(request.POST, request=request)
if form.is_valid():
form.save()
redirect_to = form.cleaned_data['origin']
if redirect_to != '/':
redirect_to = reverse(redirect_to)
return HttpResponseRedirect(redirect_to)
else:
form = form_class(request=request)
extra = {'form': form}
return render_to_response("atlas/select_location.html", extra, context_instance=RequestContext(request))
| {
"repo_name": "praekelt/django-atlas",
"path": "atlas/views.py",
"copies": "1",
"size": "2949",
"license": "bsd-3-clause",
"hash": 1577780980751388200,
"line_mean": 38.8513513514,
"line_max": 108,
"alpha_frac": 0.6358087487,
"autogenerated": false,
"ratio": 4.6078125,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5743621248699999,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpResponse
from django.core.exceptions import ValidationError
import django.views.decorators.csrf
import yaml
from django.conf import settings
from canvas import url_util
from canvas.util import ArgSpec, simple_decorator, loads, client_dumps, JSONDecodeError
from canvas.exceptions import ServiceError, DeactivatedUserError
api_functions = set()
def ServiceResponse(request, response, **kwargs):
"""
Serializes the response to primarily JSON, but you can force it to produce YAML by sending a format=yaml request
variable.
"""
formatted_response = client_dumps(response)
if request.POST.get("format") == "yaml":
formatted_response = yaml.safe_dump(loads(formatted_response), default_flow_style=False)
# Allows us to force a mimetype in a request arg.
mimetype = request.POST.get("force_mimetype", 'application/json')
return HttpResponse(formatted_response, mimetype, **kwargs)
def JSONPResponse(request, response, **kwargs):
callback = request.GET.get('callback', "callback")
if not callback.replace('_', '').isalnum():
raise ServiceError()
return HttpResponse('%s(%s);' % (callback, client_dumps(response)), mimetype="application/javascript", **kwargs)
def json_response(view):
@wraps(view)
def view_wrapper(request, *args, **kwargs):
return _handle_json_response(view, ServiceResponse, request, *args, **kwargs)
return view_wrapper
def _handle_json_response(view, json_response_processor, request, *args, **kwargs):
status_code = None
try:
response = view(request, *args, **kwargs)
except (ServiceError, ValidationError, DeactivatedUserError,), se:
response = se.to_json()
status_code = getattr(se, 'status_code', None)
else:
if response is None:
response = {}
if isinstance(response, dict):
response['success'] = True
# If the response is not a dict, we're not going to serialize it as JSON since our JSON
# services expect a "success" key.
#
# This is primarily so that we can handle returning an HTTP response from the view, for
# redirects and the like.
if isinstance(response, dict):
response_kwargs = {}
if status_code:
response_kwargs['status_code'] = status_code
return json_response_processor(request, response, **response_kwargs)
return response
def _bad_json_view(*args, **kwargs):
raise ServiceError("malformed json")
def _json_service_wrapper(json_response_processor, view):
def view_wrapper(request, *args, **kwargs):
try:
request.JSON = loads(request.raw_post_data) if request.raw_post_data else {}
except JSONDecodeError:
temp_view = _bad_json_view
else:
temp_view = view
return _handle_json_response(temp_view, json_response_processor, request, *args, **kwargs)
return view_wrapper
#TODO use functools.wraps instead of simple_decorator
@simple_decorator
def json_service(view):
return _json_service_wrapper(ServiceResponse, view)
#TODO use functools.wraps
def public_jsonp_service(view):
"""
More explicitly named to call attention to the extra little p
"""
return _json_service_wrapper(JSONPResponse, view)
def is_api(view):
return getattr(view, 'is_api', False)
def api_response_wrapper(public_jsonp=False, csrf_exempt=False):
serializer = public_jsonp_service if public_jsonp else json_service
csrf_wrapper = django.views.decorators.csrf.csrf_exempt if (csrf_exempt or settings.API_CSRF_EXEMPT) else lambda f: f
return csrf_wrapper(serializer)
def inner_api(url_decorator, force_csrf_exempt=False):
def api(url, public_jsonp=False, skip_javascript=False, async=True, csrf_exempt=False):
"""
`url` is a static URL endpoint, not a regex pattern.
Requires JSON payloads in the request's raw POST data (which doesn't need to be used by the view, but the
POST headers can't be used for anything else.) `request.GET` is still usable (for when it makes XSS easier),
but this decorator doesn't help with that by generating anything in canvas_api.js for it, as it does for the
JSON parameters.
This also doesn't support *args or **kwargs inside the API view's arguments yet (i.e. it won't generate
anything in the JS API for these.) It does support explicitly named args and kwargs though. The kwargs are
used to provide default values to optional params (or simply to make them optional without a default).
The order of args in an API view's arg list doesn't actually matter (besides `request` being first), since
the JS API sends everything as a JSON dictionary of arg name, value pairs (which is unordered.)
If `public_jsonp` is True, this will return a JSONP response, and will work with GET. This is False by
default -- the response is serialized into JSON, not JSONP, and POST is required.
NOTE:
This *must* be the first (outermost) decorator on the view.
"""
response_wrapper = api_response_wrapper(public_jsonp=public_jsonp, csrf_exempt=(csrf_exempt or force_csrf_exempt))
def decorator(func):
try:
func.url_name = u'api-{0}-{1}'.format(func.__module__, func.__name__)
except AttributeError:
func.url_name = None
# We assume the function's arg specs don't change at runtime. Seems to be a reasonable assumption. If we
# couldn't assume that, then our JS API could diverge from the actual function signatures. We can't have
# that happening. So we just precompute it here.
if not getattr(func, 'arg_spec', None):
func.arg_spec = ArgSpec(func)
if not public_jsonp:
from canvas.view_guards import require_POST
func = require_POST(func)
# Mark it as an API.
func.is_api = True
func.async = async
if not skip_javascript:
api_functions.add((func.__name__, func))
@url_decorator(r'^' + url + r'$', name=func.url_name)
@response_wrapper
@wraps(func)
def wrapped_view(request):
# JSON or REQUEST. The latter is to support the API console.
payload = request.JSON
if not payload:
try:
payload = request.REQUEST
except AttributeError:
pass
args, kwargs = [], {}
# Skip the `request` arg.
for arg_name in func.arg_spec.args[1:]:
try:
args.append(payload[arg_name])
except KeyError:
raise ServiceError("Request payload is missing a required parameter: " + arg_name)
for kwarg_name in func.arg_spec.kwargs.iterkeys():
if kwarg_name in payload:
kwargs[kwarg_name] = payload[kwarg_name]
return func(request, *args, **kwargs)
return wrapped_view
return decorator
return api
def api_decorator(urls):
""" Returns an API decorator for the given URL space. """
url_decorator = url_util.url_decorator(urls)
return inner_api(url_decorator)
| {
"repo_name": "canvasnetworks/canvas",
"path": "website/canvas/api_decorators.py",
"copies": "1",
"size": "7487",
"license": "bsd-3-clause",
"hash": -7852641585767367000,
"line_mean": 40.5944444444,
"line_max": 122,
"alpha_frac": 0.6415119541,
"autogenerated": false,
"ratio": 4.251561612720045,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5393073566820045,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpResponse
from django.core.urlresolvers import reverse
from django.core.handlers.wsgi import WSGIRequest
from fandjango.utils import get_post_authorization_redirect_url
from fandjango.views import authorize_application
from fandjango.settings import FACEBOOK_APPLICATION_DOMAIN
from fandjango.settings import FACEBOOK_APPLICATION_NAMESPACE
from fandjango.settings import FACEBOOK_APPLICATION_INITIAL_PERMISSIONS
from fandjango.settings import FACEBOOK_AUTHORIZATION_REDIRECT_URL
def facebook_authorization_required(redirect_uri=FACEBOOK_AUTHORIZATION_REDIRECT_URL, permissions=None):
"""
Require the user to authorize the application.
:param redirect_uri: A string describing an URL to redirect to after authorization is complete.
If ``None``, redirects to the current URL in the Facebook canvas
(e.g. ``http://apps.facebook.com/myapp/current/path``). Defaults to
``FACEBOOK_AUTHORIZATION_REDIRECT_URL`` (which, in turn, defaults to ``None``).
:param permissions: A list of strings describing Facebook permissions.
"""
def decorator(function):
@wraps(function)
def wrapper(request, *args, **kwargs):
# We know the user has been authenticated via a canvas page if a signed request is set.
canvas = request.facebook is not False and hasattr(request.facebook, "signed_request")
# The user has already authorized the application, but the given view requires
# permissions besides the defaults listed in ``FACEBOOK_APPLICATION_DEFAULT_PERMISSIONS``.
#
# Derive a list of outstanding permissions and prompt the user to grant them.
if request.facebook and request.facebook.user and permissions:
outstanding_permissions = [p for p in permissions if p not in request.facebook.user.permissions]
if outstanding_permissions:
return authorize_application(
request = request,
redirect_uri = redirect_uri or get_post_authorization_redirect_url(request, canvas=canvas),
permissions = outstanding_permissions
)
# The user has not authorized the application yet.
#
# Concatenate the default permissions with permissions required for this particular view.
if not request.facebook or not request.facebook.user:
return authorize_application(
request = request,
redirect_uri = redirect_uri or get_post_authorization_redirect_url(request, canvas=canvas),
permissions = (FACEBOOK_APPLICATION_INITIAL_PERMISSIONS or []) + (permissions or [])
)
return function(request, *args, **kwargs)
return wrapper
if callable(redirect_uri):
function = redirect_uri
redirect_uri = None
return decorator(function)
else:
return decorator
| {
"repo_name": "jgorset/fandjango",
"path": "fandjango/decorators.py",
"copies": "1",
"size": "3107",
"license": "mit",
"hash": 4698214394024866000,
"line_mean": 46.8,
"line_max": 115,
"alpha_frac": 0.663984551,
"autogenerated": false,
"ratio": 5.003220611916264,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.005265685115974785,
"num_lines": 65
} |
from functools import wraps
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django.utils import simplejson
from django.template import RequestContext
def render_to(template=None):
def renderer(function):
@wraps(function)
def wrapper(request, *args, **kwargs):
output = function(request, *args, **kwargs)
if not isinstance(output, dict):
return output
tmpl = output.pop('TEMPLATE', template)
return render_to_response(tmpl, output, context_instance=RequestContext(request))
return wrapper
return renderer
class JsonResponse(HttpResponse):
def __init__(self, data):
super(JsonResponse, self).__init__(content=simplejson.dumps(data), mimetype='application/json')
def ajax_request(func):
@wraps(func)
def wrapper(request, *args, **kwargs):
response = func(request, *args, **kwargs)
if isinstance(response, dict):
return JsonResponse(response)
else:
return response
return wrapper
| {
"repo_name": "dbreen/mazerunjs",
"path": "mazerun/utils/decorators.py",
"copies": "1",
"size": "1093",
"license": "mit",
"hash": -798625285044599300,
"line_mean": 30.2285714286,
"line_max": 103,
"alpha_frac": 0.6605672461,
"autogenerated": false,
"ratio": 4.573221757322176,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0005786766425064298,
"num_lines": 35
} |
from functools import wraps
from django.http import HttpResponse
from django.template.loader import render_to_string, get_template
from django.template import RequestContext
from slimmer import slimmer
from paucore.utils.data import is_seq_not_string
from paucore.stats.statsd_client import graphite_timer
def minify(html):
"Convenience method."
if isinstance(html, unicode):
html = html.encode('utf-8')
return slimmer.html_slimmer(html)
def render_template_string(request, ctx, template, minify_html=None, extra_ctx=None):
with graphite_timer('jinja2.render_template_string'):
if minify_html is None:
minify_html = template.endswith('.html')
if extra_ctx:
if not is_seq_not_string(extra_ctx):
extra_ctx = [extra_ctx]
new_ctx = {}
page_load_hooks = ctx.get('__js_page_load_hooks', [])
for ctx_callable in extra_ctx:
ctx_item = ctx_callable(request)
if ctx_item:
if '__js_page_load_hooks' in ctx_item:
page_load_hooks.extend(ctx_item['__js_page_load_hooks'])
del ctx_item['__js_page_load_hooks']
new_ctx.update(ctx_item)
new_ctx.update(ctx)
new_ctx['__js_page_load_hooks'] = page_load_hooks
ctx = new_ctx
with graphite_timer('jinja2.render_to_string'):
output = render_to_string(template, ctx, context_instance=RequestContext(request))
if isinstance(output, unicode):
output = output.encode('utf-8')
if ctx and ctx.get('__no_minify'):
minify_html = False
if minify_html:
with graphite_timer('jinja2.minify_html'):
output = slimmer.html_slimmer(output)
return output
def get_macro_module(request, ctx, template):
"""Fetch a module that represents a template for the purpose of rendering individual macros as snippets."""
ctx = ctx or {}
t = get_template(template)
if hasattr(t, 'make_module'):
context_instance = RequestContext(request)
context_instance.update(ctx)
flat_dict = {}
for d in context_instance.dicts:
flat_dict.update(d)
return t.make_module(t.new_context(flat_dict))
else:
raise Exception('get_macro_module only works for Jinja2 templates')
def render_template_response(request, ctx, template, no_cache=False, minify_html=None, extra_ctx=None, status_code=200):
response = HttpResponse(render_template_string(request, ctx, template, minify_html, extra_ctx), status=status_code)
if no_cache:
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache, must-revalidate'
return response
def template_response(template, no_cache=False, minify_html=None, extra_ctx=None):
def render_template_decorator(view):
@wraps(view)
def inner(request, *a, **kw):
ctx = view(request, *a, **kw)
if isinstance(ctx, HttpResponse):
return ctx
else:
return render_template_response(request, ctx, template, no_cache=no_cache, minify_html=minify_html,
extra_ctx=extra_ctx)
return inner
return render_template_decorator
| {
"repo_name": "appdotnet/alpha",
"path": "paucore/web/template.py",
"copies": "3",
"size": "3387",
"license": "mit",
"hash": -3479823916990917600,
"line_mean": 31.2571428571,
"line_max": 120,
"alpha_frac": 0.6111603189,
"autogenerated": false,
"ratio": 3.902073732718894,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6013234051618894,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpResponse
def _action_renderer(renderer, **renderer_kwargs):
def decorator(function):
@wraps(function)
def _wrapped_action(self, *args, **kwargs):
"""Wrapper for the function called by the url."""
response = function(self, *args, **kwargs)
if issubclass(response.__class__, HttpResponse):
return response
return getattr(self,renderer)(response, **renderer_kwargs)
return _wrapped_action
return decorator
def json_action(json_encoder=None):
"""
Decorator that ensures any data returned from this function is encoded into JSON.
"""
return _action_renderer(json_encoder=json_encoder, renderer="_as_json")
def yaml_action(default_flow_style=None):
return _action_renderer(default_flow_style=default_flow_style, renderer="_as_yaml")
def auto(json_encoder=None, yaml_default_flow_style=None):
"""
Decorator that determines the returned data renderer based on the Accept header.
Be careful, if used incorrectly this can expose your data to an attacker.
Example: You request data with Accept:application/json, this means any data returned from your action
function will be encoded into JSON as is.
So if you return a dictionary with sensitive data, that normally would be processed inside a server-side
template, and someone sends Accept:application/json, your function will actually return the dictionary
that was meant for a server-side template to the client.
Supported `auto` rendering types are json, yaml, template and plain text.
"""
return _action_renderer(renderer="_as_auto_response", json_encoder=json_encoder, default_flow_style=yaml_default_flow_style)
| {
"repo_name": "zeraien/django-url-framework",
"path": "django_url_framework/decorators/render.py",
"copies": "1",
"size": "1816",
"license": "mit",
"hash": -4807058447792839000,
"line_mean": 41.2325581395,
"line_max": 128,
"alpha_frac": 0.7004405286,
"autogenerated": false,
"ratio": 4.4950495049504955,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5695490033550495,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http import HttpResponseRedirect
from .utils import get_dropbox_auth_flow
from .views import DROPBOX_ACCESS_TOKEN
def require_dropbox_session(next_url=None):
"""
Any view that is wrapped with this will redirect to the dropbox authorization site if the user does not
have an access_token in their session.
@params
next_url - The next_url to go to after redirect. Can be a function or string. If it's a function it will
receive the same parameters as the view
"""
def decorator(view_func):
@wraps(view_func)
def inner(request, *args, **kwargs):
if not request.session.get(DROPBOX_ACCESS_TOKEN, None):
url = '/'
if hasattr(next_url, '__call__'):
url = next_url(request, *args, **kwargs)
elif next_url:
url = next_url
request.session['dropbox_next_url'] = url
authorize_url = get_dropbox_auth_flow(request.session).start()
return HttpResponseRedirect(authorize_url)
return view_func(request, *args, **kwargs)
return inner
return decorator
| {
"repo_name": "qedsoftware/commcare-hq",
"path": "corehq/apps/dropbox/decorators.py",
"copies": "2",
"size": "1200",
"license": "bsd-3-clause",
"hash": -5184034912629061000,
"line_mean": 36.5,
"line_max": 108,
"alpha_frac": 0.6216666667,
"autogenerated": false,
"ratio": 4.363636363636363,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0005760490995582739,
"num_lines": 32
} |
from functools import wraps
from django.http import *
from django.shortcuts import render_to_response
from django.template.context import RequestContext
from merlin.wizards import MissingStepException, MissingSlugException
from merlin.wizards.utils import *
def modifies_session(func):
@wraps(func)
def wrapper(self, request, *args, **kwargs):
result = func(self, request, *args, **kwargs)
request.session.modified = True
return result
return wrapper
class SessionWizard(object):
"""
This class allows for the ability to chop up a long form into sizable steps
and process each step in sequence. It also provides the ability to go back
to a previous step or move on to the next step in the sequence. When the
wizard runs out of steps it calls a final function that finishes the form
process. This class should be subclassed and the subclass should at a
minimum override the ``done`` method.
.. versionadded:: 0.1
:param steps:
Provides a list of :class:`Step` objects in the order in
which the wizard should display them to the user. This list can
be manipulated to add or remove steps as needed.
"""
def __init__(self, steps):
if not isinstance(steps, list):
raise TypeError('steps must be an instance of or subclass of list')
if [step for step in steps if not isinstance(step, Step)]:
raise TypeError('All steps must be an instance of Step')
slugs = set([step.slug for step in steps])
# By putting the slugs into a set the duplicates will be filtered out.
# If the slug list length does not equal the steps length then there
# must have been duplicates.
if len(slugs) != len(steps):
raise ValueError('Step slugs must be unique.')
clazz = self.__class__
self.id = '%s.%s' % (clazz.__module__, clazz.__name__,)
self.base_steps = steps
def __call__(self, request, *args, **kwargs):
"""
Initialize the step list for the session if needed and call the proper
HTTP method handler.
"""
self._init_wizard(request)
slug = kwargs.get('slug', None)
if not slug:
raise MissingSlugException("Slug not found.")
step = self.get_step(request, slug)
if not step:
if slug == 'cancel':
self.cancel(request)
redirect = request.REQUEST.get('rd', '/')
return HttpResponseRedirect(redirect)
raise MissingStepException("Step for slug %s not found." % slug)
method_name = 'process_%s' % request.method
method = getattr(self, method_name)
return method(request, step)
def _init_wizard(self, request):
"""
Since the SessionWizard can be used as the callable for the urlconf
there will be only one instance of the class created. We need to
make sure each session has its own copy of the step list to manipulate.
This way multiple connections will not trample on each others steps.
"""
if self.id not in request.session:
request.session[self.id] = WizardState(
steps=self.base_steps[:], # Copies the list
current_step=self.base_steps[0],
form_data={})
self.initialize(request, request.session[self.id])
def _get_state(self, request):
"""
Returns the :class:`WizardState` object used to manage this
wizards internal state.
"""
return request.session[self.id]
def _show_form(self, request, step, form):
"""
Render the provided form for the provided step to the
response stream.
"""
context = self.process_show_form(request, step, form)
return self.render_form(request, step, form, {
'current_step': step,
'form': form,
'previous_step': self.get_before(request, step),
'next_step': self.get_after(request, step),
'url_base': self._get_URL_base(request, step),
'extra_context': context
})
def _set_current_step(self, request, step):
"""
Sets the currenlty executing step.
"""
self._get_state(request).current_step = step
return step
def _get_URL_base(self, request, step):
"""
Returns the base URL of the wizard.
"""
index = request.path.rfind(step.slug)
return request.path[:index]
def process_GET(self, request, step):
"""
Renders the ``Form`` for the requested :class:`Step`
"""
form_data = self.get_cleaned_data(request, step)
if form_data:
form = step.form(form_data)
else:
form = step.form()
return self._show_form(request, step, form)
def process_POST(self, request, step):
"""
Processes the current :class:`Step` and either send a redirect to the
next :class:`Step` in the sequence or finished the wizard process
by calling ``self.done``
"""
form = step.form(request.POST)
if not form.is_valid():
return self._show_form(request, step, form)
self.set_cleaned_data(request, step, form.cleaned_data)
self.process_step(request, step, form)
next_step = self.get_after(request, step)
if next_step:
url_base = self._get_URL_base(request, step)
return HttpResponseRedirect(urljoin(url_base, next_step.slug))
else:
return self.done(request)
def get_steps(self, request):
"""
Returns the list of :class:`Step`s used in this wizard sequence.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
"""
return self._get_state(request).steps
def get_step(self, request, slug):
"""
Returns the :class:`Step` that matches the provided slug.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param slug:
The unique identifier for a particular :class:`Step` in the
sequence.
"""
steps = self.get_steps(request)
try:
return [step for step in steps if step.slug == slug][0]
except IndexError:
return None
def get_before(self, request, step):
"""
Returns the previous :class:`Step` in the sequence after the provided
:class:`Step`. This function will return ``None`` if there is no
previous step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The :class:`Step` to use as an index for finding the next
:class:`Step`
"""
steps = self.get_steps(request)
index = steps.index(step)
if index > 0:
return steps[index - 1]
else:
return None
def get_after(self, request, step):
"""
Returns the next :class:`Step` in the sequence after the provided
:class:`Step`. This function will return ``None`` if there is no
next step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The :class:`Step` to use as an index for finding the next
:class:`Step`
"""
steps = self.get_steps(request)
index = steps.index(step)
try:
return steps[index + 1]
except IndexError:
return None
@modifies_session
def remove_step(self, request, step):
"""
Removes step from the wizard sequence.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The :class:`Step` to remove.
"""
steps = self.get_steps(request)
if step in steps:
steps.remove(step)
@modifies_session
def insert_before(self, request, current_step, step):
"""
Inserts a new step into the wizard sequence before the provided step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param current_step:
The :class:`Step` to use as an index for inserting a new step
:param step:
The new :class:`Step` to insert.
"""
steps = self.get_steps(request)
if step not in steps:
index = steps.index(current_step)
steps.insert(index, step)
@modifies_session
def insert_after(self, request, current_step, step):
"""
Inserts a new step into the wizard sequence after the provided step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param current_step:
The :class:`Step` to use as an index for inserting a new step
:param step:
The new :class:`Step` to insert.
"""
steps = self.get_steps(request)
if step not in steps:
index = steps.index(current_step) + 1
steps.insert(index, step)
def get_cleaned_data(self, request, step):
"""
Returns the cleaned form data for the provided step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The :class:`Step` to use to pull the cleaned form data.
"""
return self._get_state(request).form_data.get(step.slug, None)
@modifies_session
def set_cleaned_data(self, request, step, data):
"""
Sets the cleaned form data for the provided step.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The :class:`Step` to use to store the cleaned form data.
:param data:
The cleaned ``Form`` data to store.
"""
self._get_state(request).form_data[step.slug] = data
def get_form_data(self, request):
"""
This will return the form_data dictionary that has been saved in the
session. This will mainly be used in the done to query for the form_data
that has been saved throughout the wizard process.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
"""
return request.session[self.id]['form_data']
def clear(self, request):
"""
Removes the internal wizard state from the session. This should be
called right be for the return from a successful
:meth:`~SessionWizard.done()` call.
"""
del request.session[self.id]
# METHODS SUBCLASSES MIGHT OVERRIDE IF APPROPRIATE ########################
def initialize(self, request, wizard_state):
"""
Hook used to initialize the wizard subclass. This will be called for
every request to the wizard before it processes the GET or POST.
:param request:
A ``HttpRequest`` object for this request.
:param wizard_state:
The :class:`WizardState` object representing the current state of
the wizard. Extra information can be appended to the state so it
can be available to :class:`Step`'s of the wizard.
For example::
if 'profile' not in wizard_state:
wizard_state.profile = request.user.get_profile()
"""
pass
def cancel(self, request):
"""
Hook used to cancel a wizard. This will be called when slug is passed
that matches "cancel". By default the method will clear the session
data.
:param request:
A ``HttpRequest`` object for this request.
"""
self.clear(request)
def process_show_form(self, request, step, form):
"""
Hook used for providing extra context that can be used in the
template used to render the current form.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The current :class:`Step` that is being processed.
:param form:
The Django ``Form`` object that is being processed.
"""
pass
def process_step(self, request, step, form):
"""
Hook for modifying the ``SessionWizard``'s internal state, given a fully
validated ``Form`` object. The ``Form`` is guaranteed to have clean,
valid data.
This method should *not* modify any of that data. Rather, it might want
dynamically alter the step list, based on previously submitted forms.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The current :class:`Step` that is being processed.
:param form:
The Django ``Form`` object that is being processed.
"""
pass
def get_template(self, request, step, form):
"""
Responsible for return the path to the template that should be used
to render this current form.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The current :class:`Step` that is being processed.
:param form:
The Django ``Form`` object that is being processed.
"""
return 'forms/wizard.html'
def render_form(self, request, step, form, context):
"""
Renders a form with the provided context and returns a ``HttpResponse``
object. This can be overridden to provide custom rendering to the
client or using a different template engine.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
:param step:
The current :class:`Step` that is being processed.
:param form:
The Django ``Form`` object that is being processed.
:param context:
The default context that templates can use which also contains
any extra context created in the ``process_show_form`` hook.
"""
return render_to_response(self.get_template(request, step, form),
context, RequestContext(request))
def done(self, request):
"""
Responsible for processing the validated form data that the wizard
collects from the user. This function should be overridden by the
implementing subclass. This function needs to return a ``HttpResponse``
object.
:param request:
A ``HttpRequest`` object that carries along with it the session
used to access the wizard state.
"""
raise NotImplementedError("Your %s class has not defined a done() " \
"method, which is required." \
% self.__class__.__name__)
| {
"repo_name": "supercodepoet/django-merlin",
"path": "src/merlin/wizards/session.py",
"copies": "1",
"size": "15866",
"license": "bsd-3-clause",
"hash": 4313827826305920500,
"line_mean": 31.7809917355,
"line_max": 81,
"alpha_frac": 0.5914534224,
"autogenerated": false,
"ratio": 4.5855491329479765,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5677002555347976,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.http.response import HttpResponse
from atlassian_jwt_auth.frameworks.django.decorators import with_asap
def validate_asap(issuers=None, subjects=None, required=True):
"""Decorator to allow endpoint-specific ASAP authorization, assuming ASAP
authentication has already occurred.
:param list issuers: A list of issuers that are allowed to use the
endpoint.
:param list subjects: A list of subjects that are allowed to use the
endpoint.
:param boolean required: Whether or not to require ASAP on this endpoint.
Note that requirements will be still be verified if claims are present.
"""
def validate_asap_decorator(func):
@wraps(func)
def validate_asap_wrapper(request, *args, **kwargs):
asap_claims = getattr(request, 'asap_claims', None)
if required and not asap_claims:
message = 'Unauthorized: Invalid or missing token'
response = HttpResponse(message, status=401)
response['WWW-Authenticate'] = 'Bearer'
return response
if asap_claims:
iss = asap_claims['iss']
if issuers and iss not in issuers:
message = 'Forbidden: Invalid token issuer'
return HttpResponse(message, status=403)
sub = asap_claims.get('sub')
if subjects and sub not in subjects:
message = 'Forbidden: Invalid token subject'
return HttpResponse(message, status=403)
return func(request, *args, **kwargs)
return validate_asap_wrapper
return validate_asap_decorator
def requires_asap(issuers=None, subject_should_match_issuer=None, func=None):
"""Decorator for Django endpoints to require ASAP
:param list issuers: *required The 'iss' claims that this endpoint is from.
"""
return with_asap(func=func,
required=True,
issuers=issuers,
subject_should_match_issuer=subject_should_match_issuer)
| {
"repo_name": "atlassian/asap-authentication-python",
"path": "atlassian_jwt_auth/contrib/django/decorators.py",
"copies": "1",
"size": "2125",
"license": "mit",
"hash": 689121540848075000,
"line_mean": 38.3518518519,
"line_max": 79,
"alpha_frac": 0.6310588235,
"autogenerated": false,
"ratio": 4.363449691991787,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5494508515491786,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django import http
from django.conf import settings
from django.http import Http404
from amo.urlresolvers import reverse
def locale_switcher(f):
"""Decorator redirecting clicks on the locale switcher dropdown."""
@wraps(f)
def decorated(request, *args, **kwargs):
new_userlang = request.GET.get('userlang')
if new_userlang in settings.AMO_LANGUAGES + settings.HIDDEN_LANGUAGES:
kwargs['locale_code'] = new_userlang
to = reverse(decorated, args=args, kwargs=kwargs)
return http.HttpResponseRedirect(to)
else:
return f(request, *args, **kwargs)
return decorated
def valid_locale(f):
"""Decorator validating locale code for per-language pages."""
@wraps(f)
def decorated(request, locale_code, *args, **kwargs):
if locale_code not in (settings.AMO_LANGUAGES +
settings.HIDDEN_LANGUAGES):
raise Http404
return f(request, locale_code, *args, **kwargs)
return decorated
| {
"repo_name": "beni55/olympia",
"path": "apps/localizers/decorators.py",
"copies": "21",
"size": "1065",
"license": "bsd-3-clause",
"hash": 6118670073586490000,
"line_mean": 32.28125,
"line_max": 78,
"alpha_frac": 0.6535211268,
"autogenerated": false,
"ratio": 4.143968871595331,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
#from django import http
from django.utils import simplejson
from django.conf import settings
from django.http import HttpResponseRedirect, HttpResponse
from django.contrib.auth.decorators import login_required
from django.utils.decorators import available_attrs
def verify_required(view_func):
"""Handle non-verfied users."""
@wraps(view_func, assigned=available_attrs(view_func))
def _wrapped_view(request, *args, **kwargs):
if request.user.is_authenticated():
if request.user.profile.email_verified:
return view_func(request, *args, **kwargs)
else:
return HttpResponseRedirect('/verify_email/')
else:
return view_func(request, *args, **kwargs)
# return login_required(view_func)(request, *args, **kwargs)
return _wrapped_view
def ajax_login_required(view_func):
"""Handle non-authenticated users differently if it is an AJAX request."""
@wraps(view_func, assigned=available_attrs(view_func))
def _wrapped_view(request, *args, **kwargs):
if request.is_ajax():
if request.user.is_authenticated():
return view_func(request, *args, **kwargs)
else:
content = simplejson.dumps({'not_authenticated': True, 'login_url': settings.LOGIN_URL})
return HttpResponse(content, content_type='application/json')
else:
return login_required(view_func)(request, *args, **kwargs)
return _wrapped_view
def ajax_verify_required(view_func):
"""Handle non-verfied users differently if it is an AJAX request."""
@wraps(view_func, assigned=available_attrs(view_func))
def _wrapped_view(request, *args, **kwargs):
if request.is_ajax():
if request.user.profile.email_verified:
return view_func(request, *args, **kwargs)
else:
content = simplejson.dumps({'not_verified': True, 'login_url': '/verify_email/'})
return HttpResponse(content, content_type='application/json')
else:
return verify_required(view_func)(request, *args, **kwargs)
return _wrapped_view
| {
"repo_name": "shawiz/idlebook",
"path": "idlebook/account/decorators.py",
"copies": "1",
"size": "2226",
"license": "mit",
"hash": -5298969003886104000,
"line_mean": 38.0526315789,
"line_max": 104,
"alpha_frac": 0.641509434,
"autogenerated": false,
"ratio": 4.192090395480226,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5333599829480226,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.middleware.cache import CacheMiddleware
from django.utils.cache import add_never_cache_headers, patch_cache_control
from django.utils.decorators import decorator_from_middleware_with_args
def cache_page(*args, **kwargs):
"""
Decorator for views that tries getting the page from the cache and
populates the cache if the page isn't in the cache yet.
The cache is keyed by the URL and some data from the headers.
Additionally there is the key prefix that is used to distinguish different
cache areas in a multi-site setup. You could use the
get_current_site().domain, for example, as that is unique across a Django
project.
Additionally, all headers from the response's Vary header will be taken
into account on caching -- just like the middleware does.
"""
# We also add some asserts to give better error messages in case people are
# using other ways to call cache_page that no longer work.
if len(args) != 1 or callable(args[0]):
raise TypeError("cache_page has a single mandatory positional argument: timeout")
cache_timeout = args[0]
cache_alias = kwargs.pop('cache', None)
key_prefix = kwargs.pop('key_prefix', None)
if kwargs:
raise TypeError("cache_page has two optional keyword arguments: cache and key_prefix")
return decorator_from_middleware_with_args(CacheMiddleware)(
cache_timeout=cache_timeout, cache_alias=cache_alias, key_prefix=key_prefix
)
def cache_control(**kwargs):
def _cache_controller(viewfunc):
@wraps(viewfunc)
def _cache_controlled(request, *args, **kw):
response = viewfunc(request, *args, **kw)
patch_cache_control(response, **kwargs)
return response
return _cache_controlled
return _cache_controller
def never_cache(view_func):
"""
Decorator that adds headers to a response so that it will
never be cached.
"""
@wraps(view_func)
def _wrapped_view_func(request, *args, **kwargs):
response = view_func(request, *args, **kwargs)
add_never_cache_headers(response)
return response
return _wrapped_view_func
| {
"repo_name": "twz915/django",
"path": "django/views/decorators/cache.py",
"copies": "2",
"size": "2205",
"license": "bsd-3-clause",
"hash": 7355844347681191000,
"line_mean": 37.0172413793,
"line_max": 94,
"alpha_frac": 0.6947845805,
"autogenerated": false,
"ratio": 4.144736842105263,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5839521422605263,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.middleware.cache import CacheMiddleware
from django.utils.cache import add_never_cache_headers, patch_cache_control
from django.utils.decorators import (
available_attrs, decorator_from_middleware_with_args,
)
def cache_page(*args, **kwargs):
"""
Decorator for views that tries getting the page from the cache and
populates the cache if the page isn't in the cache yet.
The cache is keyed by the URL and some data from the headers.
Additionally there is the key prefix that is used to distinguish different
cache areas in a multi-site setup. You could use the
get_current_site().domain, for example, as that is unique across a Django
project.
Additionally, all headers from the response's Vary header will be taken
into account on caching -- just like the middleware does.
"""
# We also add some asserts to give better error messages in case people are
# using other ways to call cache_page that no longer work.
if len(args) != 1 or callable(args[0]):
raise TypeError("cache_page has a single mandatory positional argument: timeout")
cache_timeout = args[0]
cache_alias = kwargs.pop('cache', None)
key_prefix = kwargs.pop('key_prefix', None)
if kwargs:
raise TypeError("cache_page has two optional keyword arguments: cache and key_prefix")
return decorator_from_middleware_with_args(CacheMiddleware)(
cache_timeout=cache_timeout, cache_alias=cache_alias, key_prefix=key_prefix
)
def cache_control(**kwargs):
def _cache_controller(viewfunc):
@wraps(viewfunc, assigned=available_attrs(viewfunc))
def _cache_controlled(request, *args, **kw):
response = viewfunc(request, *args, **kw)
patch_cache_control(response, **kwargs)
return response
return _cache_controlled
return _cache_controller
def never_cache(view_func):
"""
Decorator that adds headers to a response so that it will
never be cached.
"""
@wraps(view_func, assigned=available_attrs(view_func))
def _wrapped_view_func(request, *args, **kwargs):
response = view_func(request, *args, **kwargs)
add_never_cache_headers(response)
return response
return _wrapped_view_func
| {
"repo_name": "craynot/django",
"path": "django/views/decorators/cache.py",
"copies": "586",
"size": "2304",
"license": "bsd-3-clause",
"hash": -6313222406767750000,
"line_mean": 37.4,
"line_max": 94,
"alpha_frac": 0.6970486111,
"autogenerated": false,
"ratio": 4.114285714285714,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0005590364800891116,
"num_lines": 60
} |
from functools import wraps
from django.middleware.csrf import CsrfViewMiddleware, get_token
from django.utils.decorators import available_attrs, decorator_from_middleware
csrf_protect = decorator_from_middleware(CsrfViewMiddleware)
csrf_protect.__name__ = "csrf_protect"
csrf_protect.__doc__ = """
This decorator adds CSRF protection in exactly the same way as
CsrfViewMiddleware, but it can be used on a per view basis. Using both, or
using the decorator multiple times, is harmless and efficient.
"""
class _EnsureCsrfToken(CsrfViewMiddleware):
# We need this to behave just like the CsrfViewMiddleware, but not reject
# requests or log warnings.
def _reject(self, request, reason):
return None
requires_csrf_token = decorator_from_middleware(_EnsureCsrfToken)
requires_csrf_token.__name__ = 'requires_csrf_token'
requires_csrf_token.__doc__ = """
Use this decorator on views that need a correct csrf_token available to
RequestContext, but without the CSRF protection that csrf_protect
enforces.
"""
class _EnsureCsrfCookie(CsrfViewMiddleware):
def _reject(self, request, reason):
return None
def process_view(self, request, callback, callback_args, callback_kwargs):
retval = super(_EnsureCsrfCookie, self).process_view(request, callback, callback_args, callback_kwargs)
# Forces process_response to send the cookie
get_token(request)
return retval
ensure_csrf_cookie = decorator_from_middleware(_EnsureCsrfCookie)
ensure_csrf_cookie.__name__ = 'ensure_csrf_cookie'
ensure_csrf_cookie.__doc__ = """
Use this decorator to ensure that a view sets a CSRF cookie, whether or not it
uses the csrf_token template tag, or the CsrfViewMiddleware is used.
"""
def csrf_exempt(view_func):
"""
Marks a view function as being exempt from the CSRF view protection.
"""
# We could just do view_func.csrf_exempt = True, but decorators
# are nicer if they don't have side-effects, so we return a new
# function.
def wrapped_view(*args, **kwargs):
return view_func(*args, **kwargs)
wrapped_view.csrf_exempt = True
return wraps(view_func, assigned=available_attrs(view_func))(wrapped_view)
| {
"repo_name": "zhoulingjun/django",
"path": "django/views/decorators/csrf.py",
"copies": "586",
"size": "2202",
"license": "bsd-3-clause",
"hash": 4937777100078680000,
"line_mean": 35.7,
"line_max": 111,
"alpha_frac": 0.7325158946,
"autogenerated": false,
"ratio": 3.960431654676259,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0001488095238095238,
"num_lines": 60
} |
from functools import wraps
from django.middleware.csrf import CsrfViewMiddleware, get_token
from django.utils.decorators import decorator_from_middleware
csrf_protect = decorator_from_middleware(CsrfViewMiddleware)
csrf_protect.__name__ = "csrf_protect"
csrf_protect.__doc__ = """
This decorator adds CSRF protection in exactly the same way as
CsrfViewMiddleware, but it can be used on a per view basis. Using both, or
using the decorator multiple times, is harmless and efficient.
"""
class _EnsureCsrfToken(CsrfViewMiddleware):
# Behave like CsrfViewMiddleware but don't reject requests or log warnings.
def _reject(self, request, reason):
return None
requires_csrf_token = decorator_from_middleware(_EnsureCsrfToken)
requires_csrf_token.__name__ = 'requires_csrf_token'
requires_csrf_token.__doc__ = """
Use this decorator on views that need a correct csrf_token available to
RequestContext, but without the CSRF protection that csrf_protect
enforces.
"""
class _EnsureCsrfCookie(CsrfViewMiddleware):
def _reject(self, request, reason):
return None
def process_view(self, request, callback, callback_args, callback_kwargs):
retval = super().process_view(request, callback, callback_args, callback_kwargs)
# Force process_response to send the cookie
get_token(request)
return retval
ensure_csrf_cookie = decorator_from_middleware(_EnsureCsrfCookie)
ensure_csrf_cookie.__name__ = 'ensure_csrf_cookie'
ensure_csrf_cookie.__doc__ = """
Use this decorator to ensure that a view sets a CSRF cookie, whether or not it
uses the csrf_token template tag, or the CsrfViewMiddleware is used.
"""
def csrf_exempt(view_func):
"""Mark a view function as being exempt from the CSRF view protection."""
# view_func.csrf_exempt = True would also work, but decorators are nicer
# if they don't have side effects, so return a new function.
def wrapped_view(*args, **kwargs):
return view_func(*args, **kwargs)
wrapped_view.csrf_exempt = True
return wraps(view_func)(wrapped_view)
| {
"repo_name": "Beauhurst/django",
"path": "django/views/decorators/csrf.py",
"copies": "124",
"size": "2073",
"license": "bsd-3-clause",
"hash": 445920326283582900,
"line_mean": 36.0178571429,
"line_max": 88,
"alpha_frac": 0.7366136035,
"autogenerated": false,
"ratio": 4.009671179883946,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import get_object_or_404
from django.utils import timezone
from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response
from core.models.machine_request import MachineRequest as CoreMachineRequest
from core.models.cloud_admin import CloudAdministrator
from core.models.provider import Provider, ProviderInstanceAction
from core.models.group import IdentityMembership
from service.driver import get_account_driver
from service.tasks.machine import start_machine_imaging
from api.permissions import ApiAuthRequired, CloudAdminRequired,\
InMaintenance
from api.v1.serializers import MachineRequestSerializer,\
IdentitySerializer, AccountSerializer,\
PATCH_ProviderInstanceActionSerializer,\
POST_ProviderInstanceActionSerializer,\
ProviderInstanceActionSerializer
def _get_administrator_accounts(user):
return CloudAdministrator.objects.filter(user=user)
def _get_administrator_account(user, admin_uuid):
try:
return CloudAdministrator.objects.get(uuid=admin_uuid, user=user)
except CloudAdministrator.DoesNotExist:
return None
class CloudAdminImagingRequestList(APIView):
"""
Cloud Administration API for handling Imaging Requests
"""
permission_classes = (ApiAuthRequired,
InMaintenance,
CloudAdminRequired,)
def get(self, request):
user = request.user
machine_reqs = CoreMachineRequest.objects.filter(
instance__source__provider__cloudadministrator__user=user
).order_by('-start_date')
serializer = MachineRequestSerializer(machine_reqs, many=True)
return Response(serializer.data)
class CloudAdminImagingRequest(APIView):
"""
This is the staff portal for machine requests
A staff member can view any machine request by its ID
"""
permission_classes = (ApiAuthRequired,
InMaintenance,
CloudAdminRequired,)
def get(self, request,
machine_request_id, action=None):
"""
OPT 1 for approval: via GET with /approve or /deny
This is a convenient way to approve requests remotely
"""
user = request.user
try:
machine_request = CoreMachineRequest.objects.get(
instance__source__provider__cloudadministrator__user=user,
id=machine_request_id)
except CoreMachineRequest.DoesNotExist:
return Response('No machine request with id %s'
% machine_request_id,
status=status.HTTP_404_NOT_FOUND)
if not action:
serializer = MachineRequestSerializer(machine_request)
return Response(serializer.data, status=status.HTTP_200_OK)
# Don't update the request unless its pending or error
# Otherwise use the existing status to 'start machine imaging'
if machine_request.old_status in ['error', 'pending']:
machine_request.old_status = action
machine_request.save()
# Only run task if status is 'approve'
if machine_request.old_status == 'approve':
start_machine_imaging(machine_request)
serializer = MachineRequestSerializer(machine_request)
return Response(serializer.data, status=status.HTTP_200_OK)
def patch(self, request,
cloud_admin_uuid, machine_request_id, action=None):
"""
OPT2 for approval: sending a PATCH to the machine request with
{"status":"approve/deny"}
Modfiy attributes on a machine request
"""
user = request.user
try:
machine_request = CoreMachineRequest.objects.get(
instance__source__provider__cloudadministrator__user=user,
id=machine_request_id)
except CoreMachineRequest.DoesNotExist:
return Response('No machine request with id %s'
% machine_request_id,
status=status.HTTP_404_NOT_FOUND)
data = request.data
# Behavior will remove 'status' if its being updated.
# Status should only be updated if denied or skipped.
# Status of 'approve','continue' will use the machine_request.status
# to allow restarting the request at the correct point in time.
start_request = False
if 'status' in data:
_status = data['status'].lower()
if machine_request.old_status == 'completed':
return Response(
"Cannot update status of 'completed' request",
status=status.HTTP_409_conflict)
elif _status in ['approve', 'continue']:
data.pop('status')
start_request = True
elif _status not in ['deny', 'skip']:
return Response(
"Bad Status Value: %s. "
"Available choices for a status update are: "
"approve, continue, deny, skip")
serializer = MachineRequestSerializer(
machine_request, data=data, partial=True)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# Only run task if status is 'approve'
machine_request = serializer.save()
mr_data = serializer.data
if start_request:
start_machine_imaging(machine_request)
return Response(mr_data, status=status.HTTP_200_OK)
class CloudAdminAccountList(APIView):
"""
This API is used to provide account management.
provider_uuid -- The id of the provider whose account you want to manage.
"""
permission_classes = (ApiAuthRequired,
InMaintenance,
CloudAdminRequired,)
def get(self, request):
"""
Return a list of ALL IdentityMemberships found on provider_uuid
"""
user = request.user
memberships = IdentityMembership.objects.filter(
identity__provider__cloudadministrator__user=user
).order_by('member__name')
serializer = AccountSerializer(memberships, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def post(self, request, cloud_admin_uuid):
"""
Passes in:
Username (To apply the identity to)
Credentials (Nested, will be applied to new identity)
"""
user = request.user
data = request.data
try:
provider_uuid = data['provider']
provider = Provider.objects.get(
cloudadministrator__user=user,
uuid=provider_uuid)
except KeyError:
return Response(
"Missing 'provider' key, Expected UUID. Received no value.",
status=status.HTTP_409_conflict)
except Exception:
return Response(
"Provider with UUID %s does not exist" % provider_uuid,
status=status.HTTP_409_conflict)
raise Exception
driver = get_account_driver(provider)
missing_args = driver.clean_credentials(data)
if missing_args:
raise Exception("Cannot create account. Missing credentials: %s"
% missing_args)
identity = driver.create_account(**data)
serializer = IdentitySerializer(identity)
# TODO: Account creation SHOULD return IdentityMembership NOT identity.
return Response(serializer.data)
class CloudAdminAccount(APIView):
"""
This API is used to Enable/Disable a specific identity on
your Cloud Provider.
"""
permission_classes = (ApiAuthRequired,
InMaintenance,
CloudAdminRequired,)
def get(self, request, username):
"""
Detailed view of all identities for provider,user combination.
username -- The username to match identities
"""
user = request.user
memberships = IdentityMembership.objects.filter(
identity__provider__cloudadministrator__user=user,
identity__created_by__username=username).order_by('member__name')
serializer = AccountSerializer(memberships, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
class CloudAdminInstanceActionList(APIView):
"""
This API is used to provide account management.
provider_uuid -- The id of the provider whose account you want to manage.
"""
def get(self, request):
"""
Return a list of ALL users found on provider_uuid
"""
p_instance_actions = ProviderInstanceAction.objects.filter(
provider__cloudadministrator__user=request.user,
)
serializer = ProviderInstanceActionSerializer(
p_instance_actions, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def post(self, request):
"""
Create a new "ProviderInstanceAction"
"""
data = request.data
serializer = POST_ProviderInstanceActionSerializer(data=data)
if serializer.is_valid():
new_action = serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class CloudAdminInstanceAction(APIView):
"""
This API is used to provide account management.
provider_uuid -- The id of the provider whose account you want to manage.
"""
permission_classes = (ApiAuthRequired,
InMaintenance,
CloudAdminRequired,)
def get(self, request, provider_instance_action_id):
"""
Return a list of ALL users found on provider_uuid
"""
try:
p_instance_action = ProviderInstanceAction.objects.get(
id=provider_instance_action_id)
except ProviderInstanceAction.DoesNotExist:
return Response("Bad ID", status=status.HTTP_400_BAD_REQUEST)
serializer = ProviderInstanceActionSerializer(p_instance_action)
return Response(serializer.data, status=status.HTTP_200_OK)
def patch(self, request, provider_instance_action_id):
"""
Return a list of ALL users found on provider_uuid
"""
data = request.data
try:
p_instance_action = ProviderInstanceAction.objects.get(
id=provider_instance_action_id)
except ProviderInstanceAction.DoesNotExist:
return Response("Bad ID", status=status.HTTP_400_BAD_REQUEST)
serializer = PATCH_ProviderInstanceActionSerializer(
p_instance_action, data=data, partial=True)
if serializer.is_valid():
p_instance_action = serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
| {
"repo_name": "CCI-MOC/GUI-Backend",
"path": "api/v1/views/cloud_admin.py",
"copies": "1",
"size": "11208",
"license": "apache-2.0",
"hash": 661885502406507300,
"line_mean": 36.2358803987,
"line_max": 79,
"alpha_frac": 0.6302640971,
"autogenerated": false,
"ratio": 4.7271193589202865,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5857383456020286,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import redirect
from django.conf import settings
from django.http import JsonResponse
from django.utils.translation import ugettext as _
from django.contrib import messages
from .models import GameControl
def registration_open_required(view):
"""
View decorator which prohibits access to the decorated view if registration is closed from the
GameControl object.
"""
@wraps(view)
def func(request, *args, **kwargs):
if not GameControl.get_instance().registration_open:
messages.error(request, _('Sorry, registration is currently closed.'))
return redirect(settings.HOME_URL)
return view(request, *args, **kwargs)
return func
def registration_closed_required(view):
"""
View decorator which only allows access to the decorated view if registration is closed from the
GameControl object.
Format of the response is currently always JSON.
"""
@wraps(view)
def func(request, *args, **kwargs):
if GameControl.get_instance().registration_open:
return JsonResponse({'error': 'Not available yet'}, status=404)
return view(request, *args, **kwargs)
return func
def before_competition_required(view):
"""
View decorator which prohibits access to the decorated view if the competition has already begun (i.e.
running or over).
"""
@wraps(view)
def func(request, *args, **kwargs):
if GameControl.get_instance().competition_started():
messages.error(request, _('Sorry, that is only possible before the competition.'))
return redirect(settings.HOME_URL)
return view(request, *args, **kwargs)
return func
def services_public_required(resp_format):
"""
View decorator which prohibits access to the decorated view if information about the services is not
public yet.
Args:
resp_format: Format of the response when the competition has not yet started. Supported options are
'html' and 'json'.
"""
def decorator(view):
@wraps(view)
def func(request, *args, **kwargs):
game_control = GameControl.get_instance()
if game_control.are_services_public():
return view(request, *args, **kwargs)
if resp_format == 'json':
return JsonResponse({'error': 'Not available yet'}, status=404)
else:
messages.error(request, _('Sorry, the page you requested is not available yet.'))
return redirect(settings.HOME_URL)
return func
return decorator
| {
"repo_name": "fausecteam/ctf-gameserver",
"path": "src/ctf_gameserver/web/scoring/decorators.py",
"copies": "1",
"size": "2671",
"license": "isc",
"hash": -905953403768192400,
"line_mean": 29.3522727273,
"line_max": 107,
"alpha_frac": 0.6548109322,
"autogenerated": false,
"ratio": 4.511824324324325,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5666635256524324,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import redirect
from django.contrib.auth import get_user_model
from .models import Blog
def create_or_edit_blog(view_func):
"""
The sole purpose of this decorator is to redirect bloggers/readers
to appropriate view depending upon their origin of request.
"""
def _create_or_edit_blog_check(request, *args, **kwargs):
def _response_decider(url_name):
"""
url_name: url_name to redirect if condition match fails.
How it works:
1. Finds current url_name.
2. checks if it is okay to visit from that url
3. If okay, goes to the view_func
4. If not, redirects to appropriate view_func.
"""
resolved_name = request.resolver_match.url_name
if resolved_name == url_name:
return view_func(request, *args, **kwargs)
else:
return redirect('blog:' + url_name)
UserModel = get_user_model()
user_id = request.user.id
user = UserModel.objects.select_related().get(pk=user_id)
# update user instance on request with related objects to save queries.
request.user = user
if user.profile.is_blogger():
# only access to create/edit views when user is a blogger.
try:
if user.blog: # this will be always true
# if user already has a blog:
# user should only be able to access blog_update view.
return _response_decider('blog_update')
except Blog.DoesNotExist:
# if user doesnt have a blog,
# user should only be able to access blog_create view.
return _response_decider('blog_create')
else:
return redirect('blog:user_blog', username=user.username)
return wraps(view_func)(_create_or_edit_blog_check)
def blogger_required(view_func):
"""
Only lets bloggers to access the supplied view and redirects readers.
"""
def _check_blogger_or_reader(request, *args, **kwargs):
UserModel = get_user_model()
user_id = request.user.id
user = UserModel.objects.select_related(
'profile', 'blog').prefetch_related().get(pk=user_id)
# update user instance on request with related objects to save queries.
request.user = user
if user.profile.is_blogger():
try:
if user.blog:
return view_func(request, *args, **kwargs)
except Blog.DoesNotExist:
return redirect('blog:blog_create')
else:
return redirect('blog:user_blog', username=request.user.username)
return wraps(view_func)(_check_blogger_or_reader)
| {
"repo_name": "v1k45/blogghar",
"path": "blog/decorators.py",
"copies": "1",
"size": "2846",
"license": "mit",
"hash": 7214531260371839000,
"line_mean": 35.4871794872,
"line_max": 79,
"alpha_frac": 0.5906535488,
"autogenerated": false,
"ratio": 4.2990936555891235,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 78
} |
from functools import wraps
from django.shortcuts import redirect
from django.template.response import TemplateResponse
from ...discount.forms import CheckoutDiscountForm
def add_voucher_form(view):
@wraps(view)
def func(request, checkout):
prefix = 'discount'
data = {k: v for k, v in request.POST.items() if k.startswith(prefix)}
voucher_form = CheckoutDiscountForm(
data or None, checkout=checkout, prefix=prefix)
if voucher_form.is_bound:
if voucher_form.is_valid():
voucher_form.apply_discount()
next_url = request.GET.get(
'next', request.META['HTTP_REFERER'])
return redirect(next_url)
else:
del checkout.discount
del checkout.voucher_code
# if only discount form was used we clear post for other forms
request.POST = {}
else:
checkout.recalculate_discount()
response = view(request, checkout)
if isinstance(response, TemplateResponse):
voucher = voucher_form.initial.get('voucher')
response.context_data['voucher_form'] = voucher_form
response.context_data['voucher'] = voucher
return response
return func
def remove_voucher_view(request, checkout):
next_url = request.GET.get('next', request.META['HTTP_REFERER'])
del checkout.discount
del checkout.voucher_code
return redirect(next_url)
| {
"repo_name": "laosunhust/saleor",
"path": "saleor/checkout/views/discount.py",
"copies": "4",
"size": "1511",
"license": "bsd-3-clause",
"hash": 327912338459951600,
"line_mean": 34.9761904762,
"line_max": 78,
"alpha_frac": 0.6201191264,
"autogenerated": false,
"ratio": 4.457227138643068,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.707734626504307,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import render
from django.http import HttpResponse
from django.http.response import HttpResponseBase
import weasyprint
def pdf_response(template_name):
"""Returns either an HTML or PDF representation of the data that
decorated function generates. Decision on format is based on "format" param
in the query string, default is "html". For PDF print CSS is used"""
def pdf_decorator(func):
@wraps(func)
def func_wrapper(request, *args, **kwargs):
context = func(request, *args, **kwargs)
if isinstance(context, HttpResponseBase):
return context
if request.GET.get('format', 'html') == 'pdf':
context["disable_css"] = True
html = render(request, template_name, context).content
base_url = request.build_absolute_uri("/")
pdf = weasyprint.HTML(
string=html, base_url=base_url).write_pdf()
response = HttpResponse(content=pdf,
content_type='application/pdf')
if "filename" in context:
response['Content-Disposition'] = (
'attachment; filename=%s.pdf' % context["filename"])
else:
response['Content-Disposition'] = 'attachment'
return response
else:
return render(request, template_name, context)
return func_wrapper
return pdf_decorator
| {
"repo_name": "dchaplinsky/pep.org.ua",
"path": "pepdb/core/pdf.py",
"copies": "1",
"size": "1568",
"license": "mit",
"hash": -133460144495013970,
"line_mean": 34.6363636364,
"line_max": 79,
"alpha_frac": 0.5797193878,
"autogenerated": false,
"ratio": 4.930817610062893,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6010536997862893,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import render
from django.shortcuts import render_to_response
from django.views.generic.base import View
from django.shortcuts import HttpResponseRedirect
from models import *
from forms import *
# Create your views here.
def check_login(func):
@wraps(func)
def decorate(self, request, *args, **kwargs):
if not request.session.get('account', None):
return HttpResponseRedirect('/')
else:
return func(self, request, *args, **kwargs)
return decorate
class BaseView(View):
pass
class IndexView(BaseView):
def get(self, request):
return render_to_response('index.html')
class StartView(BaseView):
def get(self, request):
return render(request, 'choose.html')
def post(self, request):
return HttpResponseRedirect('/resume/%s' % request.session['account'])
class LoginView(BaseView):
def get(self, request):
'''
before qq login finished
this method just for test.
:param request:
:return:
'''
account = "9527"
request.session["account"] = account
IDMap.objects.update_or_create(openid=account, name="")
return HttpResponseRedirect('/resume/%s' % account)
class LogoutView(BaseView):
def get(self, request):
request.session["account"] = None
return HttpResponseRedirect('/')
class ListView(BaseView):
@check_login
def get(self, request, pageid):
return render_to_response('list.html')
class SorryView(BaseView):
@check_login
def get(self, request):
return render_to_response('sorry.html')
class UserView(BaseView):
@check_login
def get(self, request, id):
return render(request, 'user.html')
@check_login
def post(self, request, id):
form = UserForm(request.POST, request.FILES)
if form.is_valid():
IDMap.objects.update(openid=id, name=form.cleaned_data['name'])
account = IDMap.objects.get(openid=id)
User.objects.update_or_create(
account=account,
password=form.cleaned_data['password'],
photo=request.FILES['photo'])
return render(request, 'user.html')
class ResumeView(BaseView):
@check_login
def get(self, request, id):
return render(request, 'edit.html')
@check_login
def post(self, request, id):
form = ResumeForm(request.POST)
if form.is_valid():
user = IDMap.objects.get(openid=id)
style = Style.objects.get(id=form.cleaned_data['style'])
resume = Resume(user=user,
title=form.cleaned_data['title'],
language=form.cleaned_data['language'],
style=style,
is_open=form.cleaned_data['is_open'],
content=form.cleaned_data['content'])
resume.save()
return render(request, 'edit.html')
@check_login
def delete(self, request, id):
pass
class ExportView(BaseView):
@check_login
def post(self, request):
pass
class Preview(BaseView):
@check_login
def get(self, request, id):
return render_to_response('show.html')
| {
"repo_name": "xsank/aijianli",
"path": "matrix/views.py",
"copies": "1",
"size": "3341",
"license": "mit",
"hash": -6948940851726694000,
"line_mean": 23.7481481481,
"line_max": 78,
"alpha_frac": 0.6040107752,
"autogenerated": false,
"ratio": 4.059538274605103,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5163549049805103,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import render
def render_to(template=None, content_type=None):
"""
Decorator for Django views that sends returned dict to render_to_response
function.
Template name can be decorator parameter or TEMPLATE item in returned
dictionary.
If view doesn't return dict then decorator simply returns output.
Parameters:
- template: template name to use
- content_type: content type to send in response headers
Examples:
# 1. Template name in decorator parameters
@render_to('template.html')
def foo(request):
bar = Bar.object.all()
return {'bar': bar}
# equals to
def foo(request):
bar = Bar.object.all()
return render_to_response('template.html', {'bar': bar})
# 2. Template name as TEMPLATE item value in return dictionary.
if TEMPLATE is given then its value will have higher priority
than render_to argument.
@render_to()
def foo(request, category):
template_name = '%s.html' % category
return {'bar': bar, 'TEMPLATE': template_name}
#equals to
def foo(request, category):
template_name = '%s.html' % category
return render_to_response(template_name, {'bar': bar})
"""
def renderer(function):
@wraps(function)
def wrapper(request, *args, **kwargs):
output = function(request, *args, **kwargs)
if output and not isinstance(output, dict):
return output
else:
return render(request,
output and output.get('TEMPLATE') or template,
output,
content_type=content_type
)
return wrapper
return renderer
| {
"repo_name": "michaelmior/pylinks",
"path": "pylinks/main/decorators.py",
"copies": "1",
"size": "1796",
"license": "mit",
"hash": -4070738289071998000,
"line_mean": 28.4426229508,
"line_max": 77,
"alpha_frac": 0.609688196,
"autogenerated": false,
"ratio": 4.616966580976864,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5726654776976864,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.shortcuts import render_to_response
from django.http import HttpResponse
def render_to(template=None, mobile_template=None, mimetype=None):
"""
Based upon django-annoying: https://bitbucket.org/offline/django-annoying/
Decorator for Django views that sends returned dict to render_to_response
function.
Template name can be decorator parameter or TEMPLATE item in returned
dictionary. RequestContext always added as context instance.
If view doesn't return dict then decorator simply returns output.
Parameters:
- template: template name to use
- mobile_template: template used when device is mobile device
- mimetype: content type to send in response headers
"""
def renderer(function):
@wraps(function)
def wrapper(request, *args, **kwargs):
output = function(request, *args, **kwargs)
if not isinstance(output, dict):
return output
if request.browser_info.get('ismobiledevice') and not request.session.get('force_desktop_version'):
template = mobile_template
tmpl = output.pop('TEMPLATE', template)
return render_to_response(tmpl, output, \
context_instance=RequestContext(request), mimetype=mimetype)
return wrapper
return renderer | {
"repo_name": "jamespacileo/django-smartagent",
"path": "smartagent/decorators.py",
"copies": "1",
"size": "1382",
"license": "mit",
"hash": 1948195469947212300,
"line_mean": 39.6764705882,
"line_max": 111,
"alpha_frac": 0.6808972504,
"autogenerated": false,
"ratio": 4.866197183098592,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.004250735734556682,
"num_lines": 34
} |
from functools import wraps
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.conf import settings
from django.template import Context, Template
from django.utils.encoding import smart_unicode
from django import http
from django.template.context import get_standard_processors
from turbion.bits.utils.title import gen_title
__all__ = ["status", "paged", "templated", "titled", "special_titled"]
class LocalRequestContext(Context):
def __init__(self, request, dict=None, processors=None):
Context.__init__(self, dict)
if processors is None:
processors = ()
else:
processors = tuple(processors)
for processor in get_standard_processors():
self.update(processor(request))
for processor in processors:
self.update(processor(request, self))
class PageMeta(object):
def __init__(self, request, context, template=None):
self.request = request
self.context = context
self.template = template
self.processors = []
self.status_code = 200
def __getitem__(self, name):
return self.context[name]
def add_processor(self, processor):
self.processors.append(processor)
def __setitem__(self, name, value):
self.context[name] = value
def get(self, name, default=None):
return self.context.get(name, default)
def update(self, data):
self.content.update(data)
def render_to_response(self, template=None):
context = LocalRequestContext(self.request,
self.context,
self.processors
)
if not template:
template = self.template
response = render_to_response(template,
context_instance=context
)
response.status_code = self.status_code
return response
def ensure_meta(request, response):
if isinstance(response, (tuple, list)):
return PageMeta( request=request,
context =response[0],
template=response[1])
elif isinstance(response, dict):
return PageMeta(request=request,
context=response)
return response
def status(code=200):
def _wrapper(func):
@wraps(func)
def _decor(request, *args, **kwargs):
meta = ensure_meta(request, func(request, *args, **kwargs))
if isinstance(meta, PageMeta):
meta.status_code = code
return meta
return _decor
return _wrapper
def templated(template=None):
def _wrapper(func):
@wraps(func)
def _decor(request, *args, **kwargs):
meta = ensure_meta(request, func(request, *args, **kwargs))
if isinstance(meta, PageMeta):
return meta.render_to_response(template)
return meta
return _decor
return _wrapper
def titled(**bits):
def _wrapper(func):
@wraps(func)
def _decor(request, *args, **kwargs):
def _title_processor(request, context):
defaults = {"site" : request.META['SERVER_NAME']}
defaults.update(bits)
pattern = gen_title(defaults)
template = Template(pattern)
title = template.render(context)
return {"page_title": title}
meta = ensure_meta(request, func(request, *args, **kwargs))
if isinstance(meta, PageMeta):
meta.add_processor(_title_processor)
return meta
return _decor
return _wrapper
def special_titled(**default):
def another_wrapper(**bits):
my_default = default.copy()
my_default.update(bits)
return titled(**my_default)
return another_wrapper
def paged(view_func):
@wraps(view_func)
def _decor(request, *args, **kwargs):
request.page = request.GET.get('page', 1)
return view_func(request, *args, **kwargs)
return _decor
| {
"repo_name": "strogo/turbion",
"path": "turbion/bits/utils/decorators.py",
"copies": "1",
"size": "4135",
"license": "bsd-3-clause",
"hash": 3978545124414290000,
"line_mean": 31.0542635659,
"line_max": 71,
"alpha_frac": 0.5888754534,
"autogenerated": false,
"ratio": 4.413020277481324,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00426861199521943,
"num_lines": 129
} |
from functools import wraps
from django.template.loader import render_to_string
from django.core.mail import send_mail as django_send_mail
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db.models import Q
from django.shortcuts import redirect
from django.utils.translation import ugettext as _
from modelcluster.fields import ParentalKey
from wagtail.wagtailcore.models import Page, PageRevision, GroupPagePermission
from wagtail.wagtailusers.models import UserProfile
from wagtail.utils.compat import get_related_model
def get_object_usage(obj):
"Returns a queryset of pages that link to a particular object"
pages = Page.objects.none()
# get all the relation objects for obj
relations = type(obj)._meta.get_all_related_objects(
include_hidden=True,
include_proxy_eq=True
)
for relation in relations:
related_model = get_related_model(relation)
# if the relation is between obj and a page, get the page
if issubclass(related_model, Page):
pages |= Page.objects.filter(
id__in=related_model._base_manager.filter(**{
relation.field.name: obj.id
}).values_list('id', flat=True)
)
else:
# if the relation is between obj and an object that has a page as a
# property, return the page
for f in related_model._meta.fields:
if isinstance(f, ParentalKey) and issubclass(f.rel.to, Page):
pages |= Page.objects.filter(
id__in=related_model._base_manager.filter(
**{
relation.field.name: obj.id
}).values_list(f.attname, flat=True)
)
return pages
def users_with_page_permission(page, permission_type, include_superusers=True):
# Get user model
User = get_user_model()
# Find GroupPagePermission records of the given type that apply to this page or an ancestor
ancestors_and_self = list(page.get_ancestors()) + [page]
perm = GroupPagePermission.objects.filter(permission_type=permission_type, page__in=ancestors_and_self)
q = Q(groups__page_permissions=perm)
# Include superusers
if include_superusers:
q |= Q(is_superuser=True)
return User.objects.filter(is_active=True).filter(q).distinct()
def permission_denied(request):
"""Return a standard 'permission denied' response"""
from wagtail.wagtailadmin import messages
messages.error(request, _('Sorry, you do not have permission to access this area.'))
return redirect('wagtailadmin_home')
def permission_required(permission_name):
"""
Replacement for django.contrib.auth.decorators.permission_required which returns a
more meaningful 'permission denied' response than just redirecting to the login page.
(The latter doesn't work anyway because Wagtail doesn't define LOGIN_URL...)
"""
# Construct and return a decorator function specific to the permission name
# that has been passed in
def decorator(view_func):
# decorator takes the view function, and returns the view wrapped in
# a permission check
@wraps(view_func)
def wrapped_view_func(request, *args, **kwargs):
if request.user.has_perm(permission_name):
# permission check succeeds; run the view function as normal
return view_func(request, *args, **kwargs)
else:
# permission check failed
return permission_denied(request)
return wrapped_view_func
return decorator
def any_permission_required(*perms):
"""
Decorator that accepts a list of permission names, and allows the user
to pass if they have *any* of the permissions in the list
"""
# Construct and return a decorator function specific to the permission list
# that has been passed in
def decorator(view_func):
# decorator takes the view function, and returns the view wrapped in
# a permission check
@wraps(view_func)
def wrapped_view_func(request, *args, **kwargs):
for perm in perms:
if request.user.has_perm(perm):
# permission check succeeds; run the view function as normal
return view_func(request, *args, **kwargs)
# if we get here, none of the permission checks have passed
return permission_denied(request)
return wrapped_view_func
return decorator
def send_mail(subject, message, recipient_list, from_email=None, **kwargs):
if not from_email:
if hasattr(settings, 'WAGTAILADMIN_NOTIFICATION_FROM_EMAIL'):
from_email = settings.WAGTAILADMIN_NOTIFICATION_FROM_EMAIL
elif hasattr(settings, 'DEFAULT_FROM_EMAIL'):
from_email = settings.DEFAULT_FROM_EMAIL
else:
from_email = 'webmaster@localhost'
return django_send_mail(subject, message, from_email, recipient_list, **kwargs)
def send_notification(page_revision_id, notification, excluded_user_id):
# Get revision
revision = PageRevision.objects.get(id=page_revision_id)
# Get list of recipients
if notification == 'submitted':
# Get list of publishers
recipients = users_with_page_permission(revision.page, 'publish')
elif notification in ['rejected', 'approved']:
# Get submitter
recipients = [revision.user]
else:
return
# Get list of email addresses
email_addresses = [
recipient.email for recipient in recipients
if recipient.email and recipient.id != excluded_user_id and getattr(
UserProfile.get_for_user(recipient),
notification + '_notifications'
)
]
# Return if there are no email addresses
if not email_addresses:
return
# Get email subject and content
template = 'wagtailadmin/notifications/' + notification + '.html'
rendered_template = render_to_string(template, dict(revision=revision, settings=settings)).split('\n')
email_subject = rendered_template[0]
email_content = '\n'.join(rendered_template[1:])
# Send email
send_mail(email_subject, email_content, email_addresses)
| {
"repo_name": "serzans/wagtail",
"path": "wagtail/wagtailadmin/utils.py",
"copies": "1",
"size": "6366",
"license": "bsd-3-clause",
"hash": -421064001848345200,
"line_mean": 35.3771428571,
"line_max": 107,
"alpha_frac": 0.6564561734,
"autogenerated": false,
"ratio": 4.402489626556017,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5558945799956017,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.test import SimpleTestCase
from django.test.utils import override_settings
from .. import config
__all__ = ('override_config',)
class override_config(override_settings):
"""
Decorator to modify constance setting for TestCase.
Based on django.test.utils.override_settings.
"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.original_values = {}
def __call__(self, test_func):
"""
Modify the decorated function to override config values.
"""
if isinstance(test_func, type):
if not issubclass(test_func, SimpleTestCase):
raise Exception(
"Only subclasses of Django SimpleTestCase can be "
"decorated with override_config")
return self.modify_test_case(test_func)
else:
@wraps(test_func)
def inner(*args, **kwargs):
with self:
return test_func(*args, **kwargs)
return inner
def modify_test_case(self, test_case):
"""
Override the config by modifying TestCase methods.
This method follows the Django <= 1.6 method of overriding the
_pre_setup and _post_teardown hooks rather than modifying the TestCase
itself.
"""
original_pre_setup = test_case._pre_setup
original_post_teardown = test_case._post_teardown
def _pre_setup(inner_self):
self.enable()
original_pre_setup(inner_self)
def _post_teardown(inner_self):
original_post_teardown(inner_self)
self.disable()
test_case._pre_setup = _pre_setup
test_case._post_teardown = _post_teardown
return test_case
def enable(self):
"""
Store original config values and set overridden values.
"""
# Store the original values to an instance variable
for config_key in self.options:
self.original_values[config_key] = getattr(config, config_key)
# Update config with the overriden values
self.unpack_values(self.options)
def disable(self):
"""
Set original values to the config.
"""
self.unpack_values(self.original_values)
@staticmethod
def unpack_values(options):
"""
Unpack values from the given dict to config.
"""
for name, value in options.items():
setattr(config, name, value)
| {
"repo_name": "jazzband/django-constance",
"path": "constance/test/unittest.py",
"copies": "1",
"size": "2533",
"license": "bsd-3-clause",
"hash": -6346062528089096000,
"line_mean": 28.8,
"line_max": 78,
"alpha_frac": 0.5906040268,
"autogenerated": false,
"ratio": 4.588768115942029,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 85
} |
from functools import wraps
from django.test import TestCase
from django.test.utils import override_settings
from django.core.urlresolvers import reverse
from profiles.models import AgdaUser
from mdr.models import MDRScanJob
fake_slug = 'asdfasdfasdfasdfasdf'
def with_two_jobs(orig):
@wraps(orig)
def wrapper(self):
self._job1 = MDRScanJob.objects.create(name='Egg number one', status=10, scheduler_id=12)
self._job2 = MDRScanJob.objects.create(name='Egg number two')
self._job2.user = self.user
self._job2.save()
orig(self)
# Cleanup
for job in self._job1, self._job2:
if MDRScanJob.objects.filter(pk=job.id).exists:
job.delete()
return wrapper
@override_settings(LOGGING={'handlers': {'development': {'level': 'ERROR'}}})
class TestJobViews(TestCase):
def setUp(self):
self.user = AgdaUser.objects.create_user('test@example.com', password='asdf')
def login(self):
self.client.login(username='test@example.com', password='asdf')
@property
def job1(self):
if MDRScanJob.objects.filter(pk=self._job1.id).exists:
return MDRScanJob.objects.get(pk=self._job1.id)
return None
@property
def job2(self):
if MDRScanJob.objects.filter(pk=self._job2.id).exists:
return MDRScanJob.objects.get(pk=self._job2.id)
return None
def test_list_jobs_when_not_logged_in(self):
url = reverse("jobs.views.list_jobs")
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
@with_two_jobs
def test_list_jobs_when_logged_in(self):
self.login()
response = self.client.get(reverse("jobs.views.list_jobs"))
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Egg number two')
@with_two_jobs
def test_view_job_when_not_logged_in(self):
url = reverse("jobs.views.show_results", args=[self.job1.slug])
response = self.client.get(url)
self.assertContains(response, 'Egg number one')
url = reverse("jobs.views.show_results", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Egg number two')
self.assertNotContains(response, 'Take')
@with_two_jobs
def test_view_job_when_logged_in(self):
self.login()
url = reverse("jobs.views.show_results", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Egg number one')
self.assertContains(response, 'Take')
url = reverse("jobs.views.show_results", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Egg number two')
self.assertNotContains(response, 'Take')
@with_two_jobs
def test_get_unexisting_job(self):
url = reverse("jobs.views.show_results", args=[fake_slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 404)
@with_two_jobs
def test_delete_job_when_not_logged_in(self):
url = reverse("jobs.views.delete_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Confirm job deletion')
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
url = reverse("jobs.views.delete_job", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'This job is not yours')
response = self.client.post(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'This job is not yours')
@with_two_jobs
def test_delete_job_when_logged_in(self):
self.login()
url = reverse("jobs.views.delete_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Confirm job deletion')
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
url = reverse("jobs.views.delete_job", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Confirm job deletion')
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
@with_two_jobs
def test_show_deleted_job(self):
url = reverse("jobs.views.delete_job", args=[self.job1.slug])
url_show = reverse("jobs.views.show_results", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Confirm job deletion')
self.assertEquals(self.job1.is_alive, True)
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.assertEquals(self.job1.is_alive, False)
response = self.client.get(url_show)
self.assertEquals(response.status_code, 404)
@with_two_jobs
def test_delete_deleted_job(self):
url = reverse("jobs.views.delete_job", args=[self.job1.slug])
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.assertEquals(self.job1.is_alive, False)
response = self.client.get(url)
self.assertEquals(response.status_code, 404)
response = self.client.post(url)
self.assertEquals(response.status_code, 404)
@with_two_jobs
def test_take_job(self):
self.login()
url = reverse("jobs.views.take_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, 'Take ownership of job')
self.assertEquals(self.job1.user, None)
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.assertEquals(self.job1.user, self.user)
@with_two_jobs
def test_take_deleted_job(self):
self.login()
url = reverse("jobs.views.delete_job", args=[self.job1.slug])
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.assertEquals(self.job1.is_alive, False)
url = reverse("jobs.views.take_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 404)
response = self.client.post(url)
self.assertEquals(response.status_code, 404)
@with_two_jobs
def test_rename_job_anonymous(self):
url = reverse("jobs.views.rename_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, "This job is not yours.")
response = self.client.post(url, {'name': 'Egg number 88'})
self.assertEquals(response.status_code, 200)
self.assertContains(response, "This job is not yours.")
self.assertEquals(self.job1.name, 'Egg number one')
url = reverse("jobs.views.rename_job", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, "This job is not yours.")
response = self.client.post(url, {'name': 'Egg number 88'})
self.assertEquals(response.status_code, 200)
self.assertContains(response, "This job is not yours.")
self.assertEquals(self.job2.name, 'Egg number two')
@with_two_jobs
def test_rename_job_logged_in(self):
self.login()
url = reverse("jobs.views.rename_job", args=[self.job1.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertContains(response, "This job is not yours.")
url = reverse("jobs.views.rename_job", args=[self.job2.slug])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.assertNotContains(response, "This job is not yours.")
response = self.client.post(url, {'name': 'Egg number 3'})
self.assertEquals(response.status_code, 302)
self.assertEquals(self.job2.name, 'Egg number 3')
@with_two_jobs
def test_delete_jobs_anonymous(self):
url = reverse("jobs.views.delete_jobs")
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
response = self.client.post(url, {'slug': [self.job1.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'The jobs have been deleted')
response = self.client.post(url, {'slug': [self.job2.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'You cannot delete jobs that belong to someone else.')
response = self.client.post(url, {'slug': [self.job1.slug, self.job2.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'You cannot delete jobs that belong to someone else.')
response = self.client.post(url, {'slug': [self.job1.slug, self.job2.slug, fake_slug]})
self.assertEquals(response.status_code, 404)
@with_two_jobs
def test_delete_jobs_logged_in(self):
self.login()
url = reverse("jobs.views.delete_jobs")
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
response = self.client.post(url, {'slug': [self.job1.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'The jobs have been deleted')
response = self.client.post(url, {'slug': [self.job2.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'The jobs have been deleted')
response = self.client.post(url, {'slug': [self.job1.slug, self.job2.slug]})
self.assertEquals(response.status_code, 302)
response = self.client.get('/')
self.assertContains(response, 'The jobs have been deleted')
response = self.client.post(url, {'slug': [self.job1.slug, self.job2.slug, fake_slug]})
self.assertEquals(response.status_code, 404)
| {
"repo_name": "BILS/agda",
"path": "agda/jobs/test_views.py",
"copies": "1",
"size": "10813",
"license": "mit",
"hash": 1680457305987761200,
"line_mean": 37.4804270463,
"line_max": 97,
"alpha_frac": 0.6492185332,
"autogenerated": false,
"ratio": 3.654275092936803,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.980193312595795,
"avg_score": 0.0003121000357705426,
"num_lines": 281
} |
from functools import wraps
from django.urls import reverse
def get_urlname(obj):
app_label, model_name = obj._meta.app_label, obj._meta.model_name
return u'admin:{}_{}_change'.format(app_label, model_name)
def link_list(urlname=None, short_description=None):
"""
Decorates a modeladmin method to display a list of related links.
:param urlname: optional, by default it will take the related objects change url
:param short_description: text to use as column header, optional
Usage:
>>> class MyAdmin(admin.ModelAdmin):
list_display = ('related_objects',)
@link_list('admin:myapp_relatedobject_change', short_description='my related objects')
def related_objects(self, obj):
return obj.relatedobject_set.all()
The ModelAdmin method then returns a comma-separated list of clickable links.
"""
def decorator(method):
method.allow_tags = True
if short_description:
method.short_description = short_description
@wraps(method)
def f(*args, **kwargs):
related_qs = method(*args, **kwargs)
return u', '.join(
[u'<a href="{}">{}</a>'.format(
reverse(urlname or get_urlname(rel), args=[rel.pk]),
rel
) for rel in related_qs])
return f
return decorator
| {
"repo_name": "Clarity-89/clarityv2",
"path": "src/clarityv2/utils/admin/decorators.py",
"copies": "1",
"size": "1418",
"license": "mit",
"hash": 4271953238066841000,
"line_mean": 31.976744186,
"line_max": 98,
"alpha_frac": 0.6057827927,
"autogenerated": false,
"ratio": 4.220238095238095,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5326020887938094,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.utils.decorators import available_attrs
from django.template.loader import render_to_string
from django.template.response import RequestContext, SimpleTemplateResponse
class BasicWidget(object):
render_template = 'filters/widget.html'
def __init__(self, extra={}, template=None):
self.template = template if template else self.render_template
self.extra = extra
def render(self, request):
return render_to_string(self.template, self.extra, context_instance=RequestContext(request))
def modify_queryset(self, request, queryset, data):
return queryset
class ContainerWidget(BasicWidget):
def __init__(self, widgets, extra={}, template=None):
super(ContainerWidget, self).__init__(extra, template)
self.widgets = widgets
def render(self, request):
rendered = []
for widget in self.widgets:
rendered.append((widget, widget.render(request)))
self.extra['widgets'] = rendered
return super(ContainerWidget, self).render(request)
def modify_queryset(self, request, queryset, data):
for widget in self.widgets:
queryset = widget.modify_queryset(request, queryset, data)
return queryset
class SortWidget(BasicWidget):
render_template = 'filters/sort_widget.html'
sort_variable = 'sort'
def __init__(self, params, default, extra={}, template=None, sort_variable=None):
super(SortWidget, self).__init__(extra, template)
self.sort_var = sort_variable if sort_variable else self.sort_variable
self.params = params
self.default = default
self.extra['sort_params'] = self.params
self.extra['sort_default'] = self.default
def modify_queryset(self, request, queryset, data):
sort = data.get(self.sort_var, self.default)
if sort not in self.params:
sort = self.default
self.extra['sort_current'] = sort
ordering = self.params[sort][0]
if callable(ordering):
return ordering(queryset)
return queryset.order_by(ordering).distinct()
class BaseFilterWidget(BasicWidget):
render_template = 'filters/filter_widget.html'
def __init__(self, name, default, extra={}, template=None):
super(BaseFilterWidget, self).__init__(extra, template)
self.name = name
self.default = default
self.extra['name'] = self.name
self.extra['default'] = default
def get_current_state(self, request, data):
return data.get(self.name, self.default)
def filter_queryset(self, request, queryset, state):
return queryset
def modify_queryset(self, request, queryset, data):
state = self.get_current_state(request, data)
return self.filter_queryset(request, queryset, state)
class FieldFilterWidget(BaseFilterWidget):
render_template = 'filters/field_filter.html'
def __init__(self, name, default, field_name, field_id, extra={}, template=None):
super(FieldFilterWidget, self).__init__(name, default, extra, template)
self.field_name = field_name
self.field_id = field_id
def filter_queryset(self, request, queryset, state):
# TODO: This stuff is temprorary, while I'll figure out how it should be
field = queryset.model.__dict__[self.field_name].field
parent_model = field.related.parent_model
self.extra['choices'] = parent_model.objects.filter(**{field.related_query_name() + '__in': queryset}).distinct()
self.extra['current'] = state
if state:
return queryset.filter(**{self.field_name + '__' + self.field_id: state})
return queryset
class OneChooseFilterWidget(BasicWidget):
render_template = 'filters/one_choose_filter.html'
class ManyChooseFilterWidget(BasicWidget):
render_template = 'filters/many_choose_filter.html'
class AnyFilterWidget(BasicWidget):
render_template = 'filters/any_filter.html'
def __init__(self, params, extra={}, template=None):
super(AnyFilterWidget, self).__init__(extra, template)
self.params = params
self.extra['filter_params'] = self.params
def modify_queryset(self, request, queryset, data):
return queryset
class FilterContainerWidget(ContainerWidget):
render_template = 'filters/filter_container.html'
FILTER_TYPES = {
'field': FieldFilterWidget,
'one_choose': OneChooseFilterWidget,
'simple': OneChooseFilterWidget,
'many_choose': ManyChooseFilterWidget,
'any': AnyFilterWidget,
}
def generate_filter(conf):
filter_type = conf.pop('type', 'simple')
if filter_type in FILTER_TYPES:
return FILTER_TYPES[filter_type](**conf)
return None
def generate_modifiers(conf):
result = {}
if 'sort' in conf:
result['sort'] = SortWidget(**conf['sort'])
if 'filter' in conf:
result['filters'] = generate_filter(conf['filter'])
if 'filters' in conf:
filters = []
for filter in conf['filters']:
filters.append(generate_filter(filter))
result['filters'] = FilterContainerWidget(filters)
return result
| {
"repo_name": "ProstoKSI/django-filters",
"path": "filters/widgets.py",
"copies": "1",
"size": "5199",
"license": "mit",
"hash": -6724157195555631000,
"line_mean": 32.3269230769,
"line_max": 121,
"alpha_frac": 0.662819773,
"autogenerated": false,
"ratio": 4.080847723704866,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.007507041565574997,
"num_lines": 156
} |
from functools import wraps
from django.utils.decorators import available_attrs
from django.template.response import SimpleTemplateResponse
from filters.widgets import generate_modifiers
def modify_queryset(conf, var_name='list'):
"""
Example of usage:
@to_template('template.html')
@modify_queryset({
'sort': {
'list': {
'var1': ('var1', _('Var 1 up')),
'var1_rev': ('-var1', _('Var 1 down')),
},
'default': 'var1',
'template': 'filters/sort_widget.html',
},
'filters': {},
})
def my_view(request):
return {'list': MyModel.objects.all()}
Better usage:
@modify_queryset(settings.MYVIEW_CHANGE_VIEW)
def my_view(request):
return TemplateRender('template.html', {'list': MyModel.objects.all()})
And somewhere in settings:
MYVIEW_CHANGE_VIEW = {
'sort': {
'var_dict': {},
'default': 'var1',
'extra': {
'wtf': '1',
},
'template': 'filters/sort_widget.html',
},
'filters': {}
}
"""
modifiers = generate_modifiers(conf)
def decorator(view_func):
def _wrapped_view(request, *args, **kwargs):
result = view_func(request, *args, **kwargs)
if isinstance(result, dict) or isinstance(result, SimpleTemplateResponse):
data = request.GET.copy()
data.update(request.POST)
rendered = {}
context = result if isinstance(result, dict) else result.context_data
for name, modifier in modifiers.items():
context[var_name] = modifier.modify_queryset(request, context[var_name], data)
for name, modifier in modifiers.items():
rendered[name] = modifier.render(request)
context['modifiers'] = rendered
return result
return wraps(view_func, assigned=available_attrs(view_func))(_wrapped_view)
return decorator
| {
"repo_name": "ProstoKSI/django-filters",
"path": "filters/decorators.py",
"copies": "1",
"size": "2201",
"license": "mit",
"hash": 8780411374258164000,
"line_mean": 35.0819672131,
"line_max": 98,
"alpha_frac": 0.5197637438,
"autogenerated": false,
"ratio": 4.556935817805383,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.018247431144613892,
"num_lines": 61
} |
from functools import wraps
from django.utils.decorators import available_attrs
from cacheback.function import FunctionJob
def cacheback(lifetime=None, fetch_on_miss=None, job_class=None,
task_options=None, **job_class_kwargs):
"""
Decorate function to cache its return value.
:lifetime: How long to cache items for
:fetch_on_miss: Whether to perform a synchronous fetch when no cached
result is found
:job_class: The class to use for running the cache refresh job. Defaults
using the FunctionJob.
:job_class_kwargs: Any extra kwargs to pass to job_class constructor.
Useful with custom job_class implementations.
"""
if job_class is None:
job_class = FunctionJob
job = job_class(lifetime=lifetime, fetch_on_miss=fetch_on_miss,
task_options=task_options, **job_class_kwargs)
def _wrapper(fn):
# using available_attrs to work around http://bugs.python.org/issue3445
@wraps(fn, assigned=available_attrs(fn))
def __wrapper(*args, **kwargs):
return job.get(fn, *args, **kwargs)
# Assign reference to unwrapped function so that we can access it
# later without descending into infinite regress.
__wrapper.fn = fn
# Assign reference to job so we can use the full Job API
__wrapper.job = job
return __wrapper
return _wrapper
| {
"repo_name": "jayfk/django-cacheback",
"path": "cacheback/decorators.py",
"copies": "5",
"size": "1455",
"license": "mit",
"hash": 7580465361136172000,
"line_mean": 37.2894736842,
"line_max": 79,
"alpha_frac": 0.6487972509,
"autogenerated": false,
"ratio": 4.24198250728863,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 38
} |
from functools import wraps
from django.utils.decorators import available_attrs
from .jobs import FunctionJob
def cacheback(lifetime=None, fetch_on_miss=None, cache_alias=None,
job_class=None, task_options=None, **job_class_kwargs):
"""
Decorate function to cache its return value.
:lifetime: How long to cache items for
:fetch_on_miss: Whether to perform a synchronous fetch when no cached
result is found
:cache_alias: The Django cache alias to store the result into.
:job_class: The class to use for running the cache refresh job. Defaults
using the FunctionJob.
:job_class_kwargs: Any extra kwargs to pass to job_class constructor.
Useful with custom job_class implementations.
"""
if job_class is None:
job_class = FunctionJob
job = job_class(lifetime=lifetime, fetch_on_miss=fetch_on_miss,
cache_alias=cache_alias, task_options=task_options,
**job_class_kwargs)
def _wrapper(fn):
# using available_attrs to work around http://bugs.python.org/issue3445
@wraps(fn, assigned=available_attrs(fn))
def __wrapper(*args, **kwargs):
return job.get(fn, *args, **kwargs)
# Assign reference to unwrapped function so that we can access it
# later without descending into infinite regress.
__wrapper.fn = fn
# Assign reference to job so we can use the full Job API
__wrapper.job = job
return __wrapper
return _wrapper
| {
"repo_name": "mitchelljkotler/django-cacheback",
"path": "cacheback/decorators.py",
"copies": "1",
"size": "1572",
"license": "mit",
"hash": 8640025893309128000,
"line_mean": 38.3,
"line_max": 79,
"alpha_frac": 0.6450381679,
"autogenerated": false,
"ratio": 4.225806451612903,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5370844619512902,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.utils.decorators import available_attrs
from rtime.utils import add_frame_data
def request_wrapper(meth):
@wraps(meth, assigned=available_attrs(meth))
def process_request(request):
res = meth(request)
if res is not None:
m_class = meth.__self__.__class__
request.view = '{}.{}.process_request'.format(
m_class.__module__, m_class.__name__
)
return res
return process_request
def view_wrapper(meth):
@wraps(meth, assigned=available_attrs(meth))
def process_view(request, *args, **kwargs):
res = meth(request, *args, **kwargs)
if res is not None:
m_class = meth.__self__.__class__
request.view = '{}.{}.process_view'.format(
m_class.__module__, m_class.__name__
)
return res
return process_view
def exception_wrapper(meth):
@wraps(meth, assigned=available_attrs(meth))
def process_exception(request, exception):
res = meth(request, exception)
if res is not None:
m_class = meth.__self__.__class__
request.view = '{}.{}.process_exception'.format(
m_class.__module__, m_class.__name__
)
return res
return process_exception
def template_response_wrapper(meth):
@wraps(meth, assigned=available_attrs(meth))
def process_template_response(request, response):
current_status = response.status_code
res = meth(request, response)
if res is not None:
if current_status != res.status_code:
m_class = meth.__self__.__class__
request.view = '{}.{}.process_template_response'.format(
m_class.__module__, m_class.__name__
)
return res
return process_template_response
def response_wrapper(meth):
@wraps(meth, assigned=available_attrs(meth))
def process_response(request, response):
current_status = response.status_code
res = meth(request, response)
if res is not None:
if current_status != res.status_code:
m_class = meth.__self__.__class__
request.view = '{}.{}.process_response'.format(
m_class.__module__, m_class.__name__
)
return res
return process_response
def execute(self, sql, params=None):
add_frame_data(query=sql, query_params=params)
return self._execute(sql, params)
| {
"repo_name": "amitu/rtime",
"path": "src/djrtime/djrtime/wrappers.py",
"copies": "1",
"size": "2539",
"license": "bsd-3-clause",
"hash": 5993170580413778000,
"line_mean": 31.1392405063,
"line_max": 72,
"alpha_frac": 0.5750295392,
"autogenerated": false,
"ratio": 4.155482815057283,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5230512354257283,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.utils.decorators import available_attrs
from .toolbox import auth_handler_response
def oauth_required(scope: str = None, scope_auto: bool = False):
"""Views decorator checking user oauth token.
:param scope: scope identifier string to check token has access to the scope.
:param scope_auto: if *True* scope identifier will be built automatically
using the following format: '<application_name>:<decorated_view_name>'.
E.g.: for application named *polls* and having *detail* view scope
would be *polls:detail*.
"""
def decorated_view(view_function):
@wraps(view_function, assigned=available_attrs(view_function))
def wrapper(request, *args, **kwargs):
target_scope = scope
if scope_auto:
target_scope = '%(app_name)s:%(view_name)s' % {
'app_name': view_function.__module__.split('.')[0],
'view_name': view_function.__name__}
return auth_handler_response(request, scope=target_scope) or view_function(request, *args, **kwargs)
return wrapper
return decorated_view
| {
"repo_name": "idlesign/django-oauthost",
"path": "oauthost/decorators.py",
"copies": "1",
"size": "1176",
"license": "bsd-3-clause",
"hash": -7751082107735652000,
"line_mean": 35.75,
"line_max": 112,
"alpha_frac": 0.6445578231,
"autogenerated": false,
"ratio": 4.21505376344086,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0006576462335419814,
"num_lines": 32
} |
from functools import wraps
from django.utils.decorators import available_attrs
def header(name, value):
# View decorator that sets a response header.
#
# Example:
# @header('X-Powered-By', 'Django')
# def view(request, ...):
# ....
#
# For class-based views use:
# @method_decorator(header('X-Powered-By', 'Django'))
# def get(self, request, ...)
# ...
def decorator(func):
@wraps(func, assigned=available_attrs(func))
def inner(request, *args, **kwargs):
response = func(request, *args, **kwargs)
response[name] = value
return response
return inner
return decorator
def headers(header_map):
# View decorator that sets multiple response headers.
#
# Example:
# @headers({'Connection': 'close', 'X-Powered-By': 'Django'})
# def view(request, ...):
# ....
#
# For class-based views use:
# @method_decorator(headers({'Connection': 'close',
# 'X-Powered-By': 'Django'})
# def get(self, request, ...)
# ...
def decorator(func):
@wraps(func, assigned=available_attrs(func))
def inner(request, *args, **kwargs):
response = func(request, *args, **kwargs)
for k in header_map:
response[k] = header_map[k]
return response
return inner
return decorator
allow_origin = lambda origin: header('Access-Control-Allow-Origin', origin)
allow_origin_all = allow_origin('*') | {
"repo_name": "alexhayes/django-toolkit",
"path": "django_toolkit/view_decorators.py",
"copies": "1",
"size": "1551",
"license": "mit",
"hash": -2935130970452081000,
"line_mean": 28.2830188679,
"line_max": 75,
"alpha_frac": 0.5667311412,
"autogenerated": false,
"ratio": 3.946564885496183,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9982479992901003,
"avg_score": 0.006163206759035954,
"num_lines": 53
} |
from functools import wraps
from django.utils.decorators import available_attrs
def xframe_options_deny(view_func):
"""
Modifies a view function so its response has the X-Frame-Options HTTP
header set to 'DENY' as long as the response doesn't already have that
header set.
e.g.
@xframe_options_deny
def some_view(request):
...
"""
def wrapped_view(*args, **kwargs):
resp = view_func(*args, **kwargs)
if resp.get('X-Frame-Options') is None:
resp['X-Frame-Options'] = 'DENY'
return resp
return wraps(view_func, assigned=available_attrs(view_func))(wrapped_view)
def xframe_options_sameorigin(view_func):
"""
Modifies a view function so its response has the X-Frame-Options HTTP
header set to 'SAMEORIGIN' as long as the response doesn't already have
that header set.
e.g.
@xframe_options_sameorigin
def some_view(request):
...
"""
def wrapped_view(*args, **kwargs):
resp = view_func(*args, **kwargs)
if resp.get('X-Frame-Options') is None:
resp['X-Frame-Options'] = 'SAMEORIGIN'
return resp
return wraps(view_func, assigned=available_attrs(view_func))(wrapped_view)
def xframe_options_exempt(view_func):
"""
Modifies a view function by setting a response variable that instructs
XFrameOptionsMiddleware to NOT set the X-Frame-Options HTTP header.
e.g.
@xframe_options_exempt
def some_view(request):
...
"""
def wrapped_view(*args, **kwargs):
resp = view_func(*args, **kwargs)
resp.xframe_options_exempt = True
return resp
return wraps(view_func, assigned=available_attrs(view_func))(wrapped_view)
| {
"repo_name": "jnovinger/django",
"path": "django/views/decorators/clickjacking.py",
"copies": "145",
"size": "1747",
"license": "bsd-3-clause",
"hash": -339757166711882900,
"line_mean": 26.296875,
"line_max": 78,
"alpha_frac": 0.6433886663,
"autogenerated": false,
"ratio": 3.740899357601713,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 64
} |
from functools import wraps
from django.utils.decorators import available_attrs
def xframe_sameorigin(view_fn):
@wraps(view_fn, assigned=available_attrs(view_fn))
def _wrapped_view(request, *args, **kwargs):
response = view_fn(request, *args, **kwargs)
response['X-Frame-Options'] = 'SAMEORIGIN'
return response
return _wrapped_view
def xframe_allow(view_fn):
@wraps(view_fn, assigned=available_attrs(view_fn))
def _wrapped_view(request, *args, **kwargs):
response = view_fn(request, *args, **kwargs)
response.no_frame_options = True
return response
return _wrapped_view
def xframe_deny(view_fn):
@wraps(view_fn, assigned=available_attrs(view_fn))
def _wrapped_view(request, *args, **kwargs):
response = view_fn(request, *args, **kwargs)
response['X-Frame-Options'] = 'DENY'
return response
return _wrapped_view
def xrobots_exempt(view_fn):
@wraps(view_fn, assigned=available_attrs(view_fn))
def _wrapped_view(request, *args, **kwargs):
response = view_fn(request, *args, **kwargs)
response.no_robots_tag = True
return response
return _wrapped_view
def xrobots_tag(rule='noindex'):
def decorator(view_fn):
@wraps(view_fn, assigned=available_attrs(view_fn))
def _wrapped_view(request, *args, **kwargs):
response = view_fn(request, *args, **kwargs)
response['X-Robots-Tag'] = rule
return response
return _wrapped_view
return decorator
| {
"repo_name": "mozilla/captain",
"path": "vendor/lib/python/commonware/response/decorators.py",
"copies": "1",
"size": "1556",
"license": "mpl-2.0",
"hash": 3051555463055548400,
"line_mean": 30.12,
"line_max": 58,
"alpha_frac": 0.6420308483,
"autogenerated": false,
"ratio": 3.5688073394495414,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9710838187749541,
"avg_score": 0,
"num_lines": 50
} |
from functools import wraps
from django.utils.six.moves.urllib import parse
from django.contrib.auth import REDIRECT_FIELD_NAME
from django.contrib.auth.decorators import user_passes_test
from django.shortcuts import render
from django.contrib import messages
from django.contrib.auth.views import redirect_to_login
from django.core.exceptions import PermissionDenied
from django.core.urlresolvers import reverse_lazy
from django.utils.translation import ugettext_lazy as _
def staff_member_required(view_func, login_url=None):
"""
Ensure that the user is a logged-in staff member.
* If not authenticated, redirect to a specified login URL.
* If not staff, show a 403 page
This decorator is based on the decorator with the same name from
django.contrib.admin.views.decorators. This one is superior as it allows a
redirect URL to be specified.
"""
if login_url is None:
login_url = reverse_lazy('account_login')
@wraps(view_func)
def _checklogin(request, *args, **kwargs):
if request.user.is_active and request.user.is_staff:
return view_func(request, *args, **kwargs)
# If user is not logged in, redirect to login page
if not request.user.is_authenticated():
# If the login url is the same scheme and net location then just
# use the path as the "next" url.
path = request.build_absolute_uri()
login_scheme, login_netloc = parse.urlparse(login_url)[:2]
current_scheme, current_netloc = parse.urlparse(path)[:2]
if ((not login_scheme or login_scheme == current_scheme) and
(not login_netloc or login_netloc == current_netloc)):
path = request.get_full_path()
messages.warning(request, _("You must log in to access this page"))
return redirect_to_login(path, login_url, REDIRECT_FIELD_NAME)
else:
# User does not have permission to view this page
raise PermissionDenied
return _checklogin
def check_permissions(user, permissions):
"""
Permissions can be a list or a tuple of lists. If it is a tuple,
every permission list will be evaluated and the outcome will be checked
for truthiness.
Each item of the list(s) must be either a valid Django permission name
(model.codename) or a property or method on the User model
(e.g. 'is_active', 'is_superuser').
Example usage:
- permissions_required(['is_staff', ])
would replace staff_member_required
- permissions_required(['is_anonymous', ])
would replace login_forbidden
- permissions_required((['is_staff',], ['partner.dashboard_access']))
allows both staff users and users with the above permission
"""
def _check_one_permission_list(perms):
regular_permissions = [perm for perm in perms if '.' in perm]
conditions = [perm for perm in perms if '.' not in perm]
# always check for is_active if not checking for is_anonymous
if (conditions and
'is_anonymous' not in conditions and
'is_active' not in conditions):
conditions.append('is_active')
attributes = [getattr(user, perm) for perm in conditions]
# evaluates methods, explicitly casts properties to booleans
passes_conditions = all([
attr() if callable(attr) else bool(attr) for attr in attributes])
return passes_conditions and user.has_perms(regular_permissions)
if not permissions:
return True
elif isinstance(permissions, list):
return _check_one_permission_list(permissions)
else:
return any(_check_one_permission_list(perm) for perm in permissions)
def permissions_required(permissions, login_url=None):
"""
Decorator that checks if a user has the given permissions.
Accepts a list or tuple of lists of permissions (see check_permissions
documentation).
If the user is not logged in and the test fails, she is redirected to a
login page. If the user is logged in, she gets a HTTP 403 Permission Denied
message, analogous to Django's permission_required decorator.
"""
if login_url is None:
login_url = reverse_lazy('account_login')
def _check_permissions(user):
outcome = check_permissions(user, permissions)
if not outcome and user.is_authenticated():
raise PermissionDenied
else:
return outcome
return user_passes_test(_check_permissions, login_url=login_url)
def login_forbidden(view_func, template_name='login_forbidden.html',
status=403):
"""
Only allow anonymous users to access this view.
"""
@wraps(view_func)
def _checklogin(request, *args, **kwargs):
if not request.user.is_authenticated():
return view_func(request, *args, **kwargs)
return render(request, template_name, status=status)
return _checklogin
| {
"repo_name": "lyoniionly/django-cobra",
"path": "src/cobra/views/decorators.py",
"copies": "1",
"size": "4997",
"license": "apache-2.0",
"hash": -6817898100129555000,
"line_mean": 38.6587301587,
"line_max": 79,
"alpha_frac": 0.6704022413,
"autogenerated": false,
"ratio": 4.3189282627484875,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5489330504048487,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.utils.translation import ugettext
from .constants import SOURCE_MAP
from .formatter import Format
from .util import country_code_map, specific_location_timeframe
from accounts.models import Network
from pinecast.helpers import get_object_or_404, json_response
def requires_network(view):
@wraps(view)
def wrapper(req, *args, **kwargs):
if req.user.is_staff:
net = get_object_or_404(Network, id=req.GET.get('network'))
else:
net = get_object_or_404(Network, id=req.GET.get('network'), members__in=[req.user])
return view(req, *args, net=net, **kwargs)
return json_response(safe=False)(wrapper)
@requires_network
def network_listen_history(req, net):
pods = net.podcast_set.all()
f = (Format(req, 'listen')
.select(episode='count')
.last_thirty()
.interval()
.group('podcast')
.where(podcast=[str(p.id) for p in pods]))
return f.driver.format_intervals(
labels_map={str(p.id): p.name for p in pods},
extra_data={str(p.id): {'slug': p.slug} for p in pods})
@requires_network
def network_listen_platform_breakdown(req, net):
pods = net.podcast_set.all()
f = (Format(req, 'listen-platform')
.select(podcast='count')
.group('browser')
.last_thirty()
.where(podcast=[str(p.id) for p in pods]))
return f.driver.format_breakdown({})
@requires_network
def network_growth(req, net):
pods = net.podcast_set.all()
f = (Format(req, 'listen')
.select(episode='count')
.during('all', force=True)
.interval()
.group('podcast')
.where(podcast=[str(p.id) for p in pods]))
return f.driver.format_growth(
labels_map={str(p.id): p.name for p in pods},
extra_data={str(p.id): {'slug': p.slug} for p in pods})
@requires_network
def network_subscriber_history(req, net):
pods = net.podcast_set.all()
f = (Format(req, 'subscription')
.select(podcast='count')
.last_thirty()
.interval()
.group('podcast')
.where(podcast=[str(p.id) for p in pods])
.no_timezones())
return f.driver.format_intervals(
labels_map={str(p.id): p.name for p in pods},
extra_data={str(p.id): {'slug': p.slug} for p in pods})
@requires_network
def network_listen_breakdown(req, net):
pods = net.podcast_set.all()
f = (Format(req, 'listen')
.select(podcast='count')
.group('source')
.last_thirty()
.where(podcast=[str(p.id) for p in pods]))
return f.driver.format_intervals(SOURCE_MAP)
@requires_network
def network_subscriber_locations(req, net):
f = (Format(req, 'subscription-country')
.select(podcast='count')
.where(podcast=[str(pod.id) for pod in net.podcast_set.all()])
.during('yesterday')
.group('country'))
return f.driver.format_country_subscribers(label=ugettext('Subscribers'))
@requires_network
def network_subscriber_locations_specific_source(req, net):
return [
{'label': country_code_map[x], 'value': x} for x in
Format(req, 'subscription-country')
.select(v='count')
.where(podcast=[str(pod.id) for pod in net.podcast_set.all()])
.during('yesterday', force=True)
.group('country')
.driver.get_resulting_groups() if
x != 'XX' and x is not None and x in country_code_map]
@requires_network
@specific_location_timeframe
def network_subscriber_locations_specific(req, net, iso_code):
f = (Format(req, 'subscription-country')
.select(ip=True)
.where(
podcast=[str(pod.id) for pod in net.podcast_set.all()],
country=iso_code,
)
.during('yesterday', force=True))
return f.driver.format_ip_list('city', key_filter=('code', iso_code))
@requires_network
def network_listener_locations(req, net):
f = (Format(req, 'listen-country')
.select(podcast='count')
.where(podcast=[str(pod.id) for pod in net.podcast_set.all()])
.last_thirty()
.group('country'))
return f.driver.format_country(label=ugettext('Listens'))
@requires_network
def network_listener_locations_specific_source(req, net):
return [
{'label': country_code_map[x], 'value': x} for x in
Format(req, 'listen-country')
.select(v='count')
.where(podcast=[str(pod.id) for pod in net.podcast_set.all()])
.during('sixmonth')
.group('country')
.driver.get_resulting_groups() if
x != 'XX' and x is not None and x in country_code_map]
@requires_network
@specific_location_timeframe
def network_listener_locations_specific(req, net, iso_code):
f = (Format(req, 'listen-country')
.select(ip=True)
.where(
podcast=[str(pod.id) for pod in net.podcast_set.all()],
country=iso_code,
)
.during('yesterday'))
return f.driver.format_ip_list('city', key_filter=('code', iso_code))
| {
"repo_name": "AlmostBetterNetwork/pinecast",
"path": "analytics/views_network.py",
"copies": "3",
"size": "5288",
"license": "apache-2.0",
"hash": -8920225955085831000,
"line_mean": 31.6419753086,
"line_max": 95,
"alpha_frac": 0.5898260212,
"autogenerated": false,
"ratio": 3.4427083333333335,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5532534354533334,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.utils.translation import ugettext
import accounts.payment_plans as plans
from .constants import SOURCE_MAP
from .formatter import Format
from .util import country_code_map, restrict, specific_location_timeframe
from pinecast.helpers import get_object_or_404
from podcasts.models import PodcastEpisode
def requires_episode(view):
@wraps(view)
def wrapper(req, pod, *args, **kwargs):
ep = get_object_or_404(PodcastEpisode, podcast=pod, id=req.GET.get('episode'))
return view(req, pod, *args, ep=ep, **kwargs)
return wrapper
@restrict(plans.FEATURE_MIN_GEOANALYTICS_EP)
@requires_episode
def episode_listener_locations(req, pod, ep):
f = (Format(req, 'listen-country')
.select(podcast='count')
.where(episode=str(ep.id))
.group('country'))
return f.driver.format_country(label=ugettext('Listens'))
@restrict(plans.PLAN_STARTER)
@requires_episode
def episode_listen_platform_breakdown(req, pod, ep):
f = (Format(req, 'listen-platform')
.select(podcast='count')
.group('browser')
.last_thirty()
.where(episode=str(ep.id)))
return f.driver.format_breakdown({})
@restrict(plans.PLAN_PRO)
@requires_episode
def episode_growth(req, pod, ep):
f = (Format(req, 'listen')
.select(episode='count')
.during('all', force=True)
.interval()
.group('episode')
.where(episode=str(ep.id)))
return f.driver.format_growth(labels_map={str(ep.id): ep.title})
@restrict(plans.PLAN_PRO)
@requires_episode
def episode_listener_locations_specific_source(req, pod, ep):
return [
{'label': country_code_map[x], 'value': x} for x in
Format(req, 'listen-country')
.select(v='count')
.where(episode=str(ep.id))
.during('sixmonth')
.group('country')
.driver.get_resulting_groups() if
x != 'XX' and x is not None and x in country_code_map]
@restrict(plans.PLAN_PRO)
@specific_location_timeframe
@requires_episode
def episode_listener_locations_specific(req, pod, ep, iso_code):
f = (Format(req, 'listen-country')
.select(ip=True)
.where(episode=str(ep.id), country=iso_code)
.during('yesterday'))
return f.driver.format_ip_list('city', key_filter=('code', iso_code))
@restrict(plans.PLAN_DEMO)
@requires_episode
def episode_listen_history(req, pod, ep):
f = (Format(req, 'listen')
.select(episode='count')
.last_thirty()
.where(episode=str(ep.id)))
return f.driver.format_interval(label=ugettext('Listens'))
@restrict(plans.PLAN_DEMO)
@requires_episode
def episode_listen_breakdown(req, pod, ep):
f = (Format(req, 'listen')
.select(episode='count')
.group('source')
.last_thirty()
.where(episode=str(ep.id)))
return f.driver.format_intervals(SOURCE_MAP)
| {
"repo_name": "AlmostBetterNetwork/podmaster-host",
"path": "analytics/views_episode.py",
"copies": "3",
"size": "3009",
"license": "apache-2.0",
"hash": 1894689289248177700,
"line_mean": 28.7920792079,
"line_max": 86,
"alpha_frac": 0.6321036889,
"autogenerated": false,
"ratio": 3.3507795100222717,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5482883198922271,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from django.views.decorators.cache import cache_page as django_cache_page
import memcache
import simplejson
from canvas import util
from configuration import Config
from django.conf import settings
cache = memcache.Client(settings.MEMCACHE_HOSTS)
class DoesNotExist(object): pass
class InProcessCache(object):
def __init__(self):
self.flush()
def flush(self):
self.cache = {}
def get(self, key):
return self.cache.get(key, DoesNotExist)
def set(self, key, value):
self.cache[key] = value
def delete(self, key):
try:
del self.cache[key]
except KeyError:
pass
def __contains__(self, key):
return key in self.cache
def _call_if_not_instance_of(key, cls, *args, **kwargs):
""" If key is not an instance of cls, call it with *args and **kwargs, otherwise just return it. """
return key(*args, **kwargs) if not isinstance(key, cls) else key
def memoize(key, time=24*60*60):
""" A cache decorator that returns a CachedCall. Takes a key or a function that returns a key. """
def decorator(fxn):
def wrapper(*args, **kwargs):
cache_key = _call_if_not_instance_of(key, str, *args, **kwargs)
return CachedCall(cache_key, lambda: fxn(*args, **kwargs), time)
return wrapper
return decorator
def invalidates_cache(cc):
"""
Invalidates the cache after the function executes. Takes a CachedCall or a function that returns a CachedCall.
"""
def decorator(fxn):
def wrapper(*args, **kwargs):
# Invalidate the cache, given a CachedCall
cache_call = _call_if_not_instance_of(cc, CachedCall, *args, **kwargs)
# Execute and return the wrapped function
try:
return fxn(*args, **kwargs)
finally:
cache_call.invalidate()
return wrapper
return decorator
class CachedCall(object):
# Note that inprocess_cache is a CLASS variable. It is instantiated the first time
# this class is parsed. It is then shared by all instances of CachedCall.
inprocess_cache = InProcessCache()
default_timeout = 24 * 60 * 60
def __init__(self, key, function, timeout=default_timeout, decorator=lambda x: x, promoter=lambda x: x):
#TODO `promoter` is a temporary hack until we can instantiate Details objs based on the cached data.
self.key = key.encode('ascii')
self.timeout = timeout
self.function = function
self.cache_decorator = decorator
self.promoter = promoter
def __eq__(self, other):
return hasattr(other, 'key') and other.key == self.key
def __hash__(self):
return hash(self.key)
def __call__(self, *args, **kwargs):
return self._get(*args, **kwargs)
def _get(self, force=False, skip_decorator=False):
raw_value = self._fetch(force)
value = self.promoter(raw_value)
if not skip_decorator:
return self.cache_decorator(value)
else:
return value
def get_local_only(self):
return self.inprocess_cache.get(self.key)
def value_from_cache_data(self, cache_data):
try:
value = util.loads(cache_data)
except:
return DoesNotExist
return value
def invalidate(self):
""" Just unsets the cache without re-caching. """
# Remove from remote
cache.delete(self.key)
# Remove from class_variable/local cache.
CachedCall.inprocess_cache.delete(self.key)
def generate_cache_data(self):
""" Sets the cache. """
value = self.function()
cache_data = self.remote_set(value)
self.local_set(value)
return cache_data
def remote_set(self, value):
""" Sets the remote cache. """
cache_data = util.dumps(value)
cache.set(self.key, cache_data, self.timeout)
return cache_data
def local_set(self, value):
""" Sets the local cache. """
self.inprocess_cache.set(self.key, value)
def _fetch(self, force):
if not force:
# Can we find it in the local cache?
value = self.get_local_only()
if not value == DoesNotExist:
return value
# Is it in the remote cache?
value = self.value_from_cache_data(cache.get(self.key))
if not value == DoesNotExist:
return value
cache_data = self.generate_cache_data()
return self.value_from_cache_data(cache_data)
def force(self, *args, **kwargs):
return self._get(force=True, *args, **kwargs)
@classmethod
def multicall(cls, calls, skip_decorator=False):
if not calls:
return []
results = {}
fetch_calls = []
for call in set(calls):
value = call.get_local_only()
if value == DoesNotExist:
fetch_calls.append(call)
else:
results[call] = value
results[call] = call.promoter(results[call])
todo = []
multicall_results = cache.get_multi([call.key for call in fetch_calls])
for call in fetch_calls:
cache_data = multicall_results.get(call.key, DoesNotExist)
value = call.value_from_cache_data(cache_data) if cache_data != DoesNotExist else DoesNotExist
if value == DoesNotExist:
todo.append(call)
else:
results[call] = value
results[call] = call.promoter(results[call])
for call in todo:
results[call] = call.value_from_cache_data(call.generate_cache_data())
if results[call]:
results[call] = call.promoter(results[call])
if not skip_decorator:
for call, value in results.items():
results[call] = call.cache_decorator(value)
return [results[call] for call in calls]
@classmethod
def many_multicall(cls, *call_lists, **kwargs):
concat = sum(call_lists, [])
concat_results = cls.multicall(concat, **kwargs)
start = 0
results = []
for call_list in call_lists:
length = len(call_list)
results.append(concat_results[start:start + length])
start += length
return results
@classmethod
def queryset_details(cls, queryset, promoter=None, **kwargs):
try:
ids = queryset.values_list('id', flat=True)
model = queryset.model
except AttributeError:
ids = [obj.id for obj in queryset]
try:
model = queryset[0].__class__
except IndexError:
return []
return cls.multicall([model.details_by_id(id_, promoter=promoter) for id_ in ids], **kwargs)
@classmethod
def many_queryset_details(cls, *querysets, **kwargs):
promoter = kwargs.pop('promoter', None)
id_sets = []
for queryset in querysets:
id_sets.append(queryset.values_list('id', flat=True))
return cls.many_multicall(*[[queryset.model.details_by_id(id_, promoter=promoter) for id_ in ids] for queryset, ids in zip(querysets, id_sets)], **kwargs)
def cacheable(key):
def decorator(func):
#TODO Category.get_top = CachedCall('category:top_v2', Category._get_top)
@wraps(func)
def wrapper(*args, **kwargs):
return CachedCall(key, lambda: func(*args, **kwargs))()
return wrapper
return decorator
def cache_page(timeout):
return django_cache_page(timeout, key_prefix=settings.CACHE_KEY_PREFIX + 'page_cache')
| {
"repo_name": "drawquest/drawquest-web",
"path": "website/canvas/cache_patterns.py",
"copies": "1",
"size": "7757",
"license": "bsd-3-clause",
"hash": 2160291420709356500,
"line_mean": 31.3208333333,
"line_max": 162,
"alpha_frac": 0.5962356581,
"autogenerated": false,
"ratio": 3.9355657026889905,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.503180136078899,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from elasticsearch_dsl.response import Response
from elasticsearch_dsl.utils import AttrDict, AttrList, ObjectBase
from django.http import JsonResponse
from django.http.response import HttpResponseBase
from django.shortcuts import render
from .translator import Translator, NoOpTranslator
from .rss import Atom1FeedResponse, RssFeedResponse
def serialize_for_api(data, new_api=False, sections=None):
"""Transform complex types that we use into simple ones recursively.
Note: recursion isn't followed when we know that transformed types aren't
supposed to contain any more complex types.
TODO: this is rather ugly, would look better if views/models defined
transformations explicitly. This is hard to achieve with function-based
views, so it's pending a CBV move."""
if hasattr(data, 'to_api'):
return serialize_for_api(data.to_api(), new_api=new_api, sections=sections)
elif isinstance(data, Response):
return serialize_for_api(data.hits._l_, new_api=new_api, sections=sections)
elif isinstance(data, (AttrDict, ObjectBase)):
if new_api and hasattr(data, "api_response"):
return data.api_response(fields=sections)
else:
res = data.to_dict()
if "translator" in res:
del(res["translator"])
if hasattr(data, 'meta'):
res['id'] = data.meta.id
return res
elif isinstance(data, AttrList):
return data._l_
elif isinstance(data, dict):
return {
k: serialize_for_api(v, new_api=new_api, sections=sections)
for k, v in data.items() if not isinstance(v, (Translator, NoOpTranslator))
}
elif isinstance(data, (list, tuple, set)):
return list(map(lambda x: serialize_for_api(
x, new_api=new_api, sections=sections), data)
)
return data
def hybrid_response(template_name):
"""Returns either an HTML or JSON representation of the data that
decorated function generates. Decision on format is based on "format" param
in the query string, default is "html". For JSON serialization the data
is passed through a recursive transformation into simple types.
TODO: This would look better as a mixin for CBVs."""
def hybrid_decorator(func):
@wraps(func)
def func_wrapper(request, *args, **kwargs):
context = func(request, *args, **kwargs)
if isinstance(context, HttpResponseBase):
return context
fmt = request.GET.get('format', 'html')
sections = request.GET.getlist('section', None)
if not sections:
sections = None
if fmt == 'json':
return JsonResponse(serialize_for_api(context), safe=False)
elif fmt == 'atom':
return Atom1FeedResponse(request, serialize_for_api(context))
elif fmt == 'rss':
return RssFeedResponse(request, serialize_for_api(context))
elif fmt == 'opendata':
return JsonResponse(
serialize_for_api(context, new_api=True, sections=sections),
safe=False
)
else:
return render(request, template_name, context)
return func_wrapper
return hybrid_decorator
| {
"repo_name": "dchaplinsky/declarations.com.ua",
"path": "declarations_site/catalog/api.py",
"copies": "1",
"size": "3382",
"license": "mit",
"hash": -1329382229409496000,
"line_mean": 38.7882352941,
"line_max": 87,
"alpha_frac": 0.6363098758,
"autogenerated": false,
"ratio": 4.341463414634147,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0005590451668883042,
"num_lines": 85
} |
from functools import wraps
from elasticsearch_dsl.result import Response
from elasticsearch_dsl.utils import AttrDict, AttrList, ObjectBase
from django.http import JsonResponse
from django.shortcuts import render
def serialize_for_api(data):
"""Transform complex types that we use into simple ones recursively.
Note: recursion isn't followed when we know that transformed types aren't
supposed to contain any more complex types.
TODO: this is rather ugly, would look better if views/models defined
transformations explicitly. This is hard to achieve with function-based
views, so it's pending a CBV move."""
if hasattr(data, 'to_api'):
return serialize_for_api(data.to_api())
elif isinstance(data, Response):
return serialize_for_api(data.hits._l_)
elif isinstance(data, (AttrDict, ObjectBase)):
res = data.to_dict()
res["id"] = data._id
return res
elif isinstance(data, AttrList):
return data._l_
elif isinstance(data, dict):
return {k: serialize_for_api(v) for k, v in data.items()}
elif isinstance(data, (list, tuple)):
return list(map(serialize_for_api, data))
return data
def hybrid_response(template_name):
"""Returns either an HTML or JSON representation of the data that
decorated function generates. Decision on format is based on "format" param
in the query string, default is "html". For JSON serialization the data
is passed through a recursive transformation into simple types.
TODO: This would look better as a mixin for CBVs."""
def hybrid_decorator(func):
@wraps(func)
def func_wrapper(request, *args, **kwargs):
context = func(request, *args, **kwargs)
if request.GET.get('format', 'html') == 'json':
return JsonResponse(serialize_for_api(context), safe=False)
else:
return render(request, template_name, context)
return func_wrapper
return hybrid_decorator
| {
"repo_name": "devrand/declarations.com.ua",
"path": "declarations_site/catalog/api.py",
"copies": "1",
"size": "2021",
"license": "mit",
"hash": -4038673898076230000,
"line_mean": 37.8653846154,
"line_max": 79,
"alpha_frac": 0.6813458684,
"autogenerated": false,
"ratio": 4.2280334728033475,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5409379341203348,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from elasticsearch import Elasticsearch
_monkeypatched_es = False
def monkeypatch_es():
"""Monkey patch for elasticsearch-py 1.0+ to make it work with ES 0.90
1. tweaks elasticsearch.client.bulk to normalize return status codes
.. Note::
We can nix this whe we drop support for ES 0.90.
"""
if _monkeypatched_es:
return
def normalize_bulk_return(fun):
"""Set's "ok" based on "status" if "status" exists"""
@wraps(fun)
def _fixed_bulk(self, *args, **kwargs):
def fix_item(item):
# Go through all the possible sections of item looking
# for 'ok' and adding an additional 'status'.
for key, val in item.items():
if 'ok' in val:
val['status'] = 201
return item
ret = fun(self, *args, **kwargs)
if 'items' in ret:
ret['items'] = [fix_item(item) for item in ret['items']]
return ret
return _fixed_bulk
Elasticsearch.bulk = normalize_bulk_return(Elasticsearch.bulk)
| {
"repo_name": "mozilla/elasticutils",
"path": "elasticutils/monkeypatch.py",
"copies": "2",
"size": "1146",
"license": "bsd-3-clause",
"hash": -7957798773254024000,
"line_mean": 27.65,
"line_max": 74,
"alpha_frac": 0.5645724258,
"autogenerated": false,
"ratio": 4.1521739130434785,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5716746338843478,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from endless_pagination.settings import PAGE_LABEL, TEMPLATE_VARNAME
def page_template(template, key=PAGE_LABEL):
"""
Decorate a view that takes a *template* and *extra_context* keyword
arguments (like generic views).
The template is switched to *page_template* if request is ajax and
if *querystring_key* variable passed by the request equals to *key*.
This allows multiple ajax paginations in the same page.
The name of the page template is given as *page_template* in the
extra context.
"""
def decorator(view):
# decorator with arguments wrap
@wraps(view)
def decorated(request, *args, **kwargs):
# trust the developer: he wrote context.update(extra_context) in his view
extra_context = kwargs.setdefault("extra_context", {})
extra_context['page_template'] = template
# switch template on ajax requests
querystring_key = request.REQUEST.get("querystring_key", PAGE_LABEL)
if request.is_ajax() and querystring_key == key:
kwargs[TEMPLATE_VARNAME] = template
return view(request, *args, **kwargs)
return decorated
return decorator
def page_templates(mapping):
"""
Like the *page_template* decorator but manage multiple paginations.
You can map multiple templates to querystring_keys using the *mapping*
dict, e.g.::
@page_templates({"page_contents1.html": None,
"page_contents2.html": "go_to_page"})
def myview(request):
...
When the value of the dict is None then the default querystring_key
(defined in settings) is used.
You can use this decorator instead of chaining multiple *page_template*
calls.
"""
templates = dict((v or PAGE_LABEL, k) for k, v in mapping.items())
def decorator(view):
# decorator with arguments wrap
@wraps(view)
def decorated(request, *args, **kwargs):
# trust the developer: he wrote context.update(extra_context) in his view
extra_context = kwargs.setdefault("extra_context", {})
querystring_key = request.REQUEST.get("querystring_key", PAGE_LABEL)
template = templates.get(querystring_key)
extra_context['page_template'] = template
# switch template on ajax requests
if request.is_ajax() and template:
kwargs[TEMPLATE_VARNAME] = template
return view(request, *args, **kwargs)
return decorated
return decorator
| {
"repo_name": "unicefuganda/edtrac",
"path": "edtrac_project/endless/endless_pagination/decorators.py",
"copies": "5",
"size": "2609",
"license": "bsd-3-clause",
"hash": 3492999232462531000,
"line_mean": 41.7704918033,
"line_max": 85,
"alpha_frac": 0.6385588348,
"autogenerated": false,
"ratio": 4.348333333333334,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.7486892168133334,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from .err import Err
def signature(*types, **kwtypes):
"""Type annotations and conversions for methods.
Ignores first parameter.
"""
conversions = [(t if isinstance(t, tuple) else (t, t)) for t in types]
kwconversions = {k: (t if isinstance(t, tuple) else (t, t))
for k, t in kwtypes.items()}
def decorator(fn):
@wraps(fn)
def wrapped(self, *args, **kwargs):
args = [(arg if isinstance(arg, t) else conv(arg))
for (t, conv), arg in zip(conversions, args)]
kwargs = {k: (v if isinstance(v, t) else conv(v))
for k, (t, conv), v
in ((k, kwconversions[k], v)
for k, v in kwargs.items())}
return fn(self, *args, **kwargs)
return wrapped
return decorator
def schemes(*schemes):
"""URL scheme validation.
This validator when supplied with a list of schemes ensures that first
argument of the decorated function is a URL with one of those schemes.
"""
msg = 'The accepted schemes for %s (which are: %s) do not include: %s'
def decorator(fn):
@wraps(fn)
def wrapped(self, url, *args, **kwargs):
if url.scheme not in schemes:
raise InvalidScheme(msg % (type(self).__name__,
', '.join(schemes),
str(url.scheme)))
return fn(self, url, *args, **kwargs)
return wrapped
return decorator
class InvalidScheme(Err):
pass
| {
"repo_name": "drcloud/arx",
"path": "arx/decorators.py",
"copies": "1",
"size": "1628",
"license": "mit",
"hash": 2935184282238328300,
"line_mean": 28.6,
"line_max": 74,
"alpha_frac": 0.5343980344,
"autogenerated": false,
"ratio": 4.20671834625323,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 55
} |
from functools import wraps
from ..error import Invalid
from ..util import varargs2kwargs, getArgSpec, getParameterNames
import logging
log = logging.getLogger(__name__)
def validateDecorator( validator, method, include, exclude, onInvalid, createContext ):
if include and exclude:
raise SyntaxError("'include' and 'exclude' cannot be used at the same time")
spec = getArgSpec( method )
hasVarargs = spec.varargs is not None
varargs = spec.varargs or '*varargs'
keywords = spec.keywords or False
createContext = createContext or (lambda _validator, _data, **kwargs: _validator.context(_data))
methodParameterNames = getParameterNames( method, skipSelf=False )
skip = ()
if exclude:
skip = exclude
if include:
skip = set(methodParameterNames) - set(include)
varargs = varargs
hasVarargs = spec.varargs not in skip and hasVarargs
keywords = keywords not in skip and keywords
@wraps(method)
def __wrap( *fargs, **fkwargs):
(fargs, fkwargs, shifted ) = varargs2kwargs( method, fargs, fkwargs, skipSelf=False )
origKwargs = dict(fkwargs)
if keywords is not False:
restKwargs = dict(\
( key, fkwargs.pop(key))\
for key in list(fkwargs.keys()) if key not in methodParameterNames
)
fkwargs[ keywords ] = restKwargs
if fargs or hasVarargs:
fkwargs[ varargs ] = list(fargs)
try:
resultKwargs = createContext\
( validator
, dict( ( key, fkwargs[ key] ) for key in fkwargs if key not in skip )
, **fkwargs ).result
except Invalid as e:
if onInvalid is not None:
return onInvalid( e )
else:
raise
origKwargs.update( resultKwargs )
resultArgs = origKwargs.pop( varargs, fargs )
resultArgs = [ origKwargs.pop(key) for key in shifted ] + resultArgs
if keywords is not False:
origKwargs.update( origKwargs.pop( keywords ) )
return method( *resultArgs, **origKwargs )
return __wrap
def validate( validator, include=None, exclude=None, onInvalid=None, createContext=None ):
def __createDecorator( method ):
return validateDecorator( validator, method, include, exclude, onInvalid, createContext)
return __createDecorator
| {
"repo_name": "doncatnip/kanone",
"path": "src/kanone/adapter/native.py",
"copies": "1",
"size": "2441",
"license": "unlicense",
"hash": 8253111066359218000,
"line_mean": 29.8987341772,
"line_max": 100,
"alpha_frac": 0.6255632937,
"autogenerated": false,
"ratio": 4.245217391304347,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5370780685004347,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from .exceptions import PreconditionViolationError, PostconditionViolationError
def pre(condition):
"""
Execute a precondition function before the decorated function.
The `condition` must be a callable that receives the same keyword arguments
as the function it's being applied to.
"""
def decorator(func, *args, **kwargs):
@wraps(func)
def wrapper(*args, **kwargs):
try:
check_result = condition(*args, **kwargs)
except AssertionError as e:
raise PreconditionViolationError("Precondition check failed.") from e
if check_result != None and not check_result:
raise PreconditionViolationError("Precondition check failed")
return func(*args, **kwargs)
return wrapper
return decorator
def post(condition):
"""
Execute a postcondition function before the decorated function.
The `condition` must be a callable that receives the return value of the
function it's being applied to as its first parameter, and the keyword
arguments of the function it's applied to as its remaining parameters.
"""
def decorator(func, *args, **kwargs):
@wraps(func)
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
try:
check_result = condition(result, *args, **kwargs)
except AssertionError as e:
raise PostconditionViolationError("Precondition check failed.") from e
if check_result != None and not check_result:
raise PostconditionViolationError("Postcondition check failed")
return result
return wrapper
return decorator
| {
"repo_name": "Chiel92/fate",
"path": "fate/contract.py",
"copies": "1",
"size": "1763",
"license": "mit",
"hash": -7841796553145705000,
"line_mean": 32.9038461538,
"line_max": 86,
"alpha_frac": 0.643788996,
"autogenerated": false,
"ratio": 5.022792022792022,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0011077868936730203,
"num_lines": 52
} |
from functools import wraps
from fabric.api import env
from woven.environment import server_state, set_server_state
from woven.environment import version_state, set_version_state
def run_once_per_node(func):
"""
Decorator preventing wrapped function from running more than
once per host (not just interpreter session).
Using env.patch = True will allow the wrapped function to be run
if it has been previously executed, but not otherwise
Stores the result of a function as server state
"""
@wraps(func)
def decorated(*args, **kwargs):
if not hasattr(env,'patch'): env.patch = False
state = version_state(func.__name__)
if not env.patch and state:
verbose = " ".join([env.host,func.__name__,"completed. Skipping..."])
elif env.patch and not state:
verbose = " ".join([env.host,func.__name__,"not previously completed. Skipping..."])
else:
results = func(*args, **kwargs)
verbose =''
if results: set_version_state(func.__name__,object=results)
else: set_version_state(func.__name__)
return results
if env.verbosity and verbose: print verbose
return
return decorated
def run_once_per_version(func):
"""
Decorator preventing wrapped function from running more than
once per host and env.project_fullname (not just interpreter session).
Using env.patch = True will allow the function to be run
Stores the result of a function as server state
"""
@wraps(func)
def decorated(*args, **kwargs):
if not hasattr(env,'patch'): env.patch = False
state = version_state(func.__name__)
if not env.patch and state:
verbose = " ".join([env.host,func.__name__,"completed. Skipping..."])
elif env.patch and not state:
verbose = " ".join([env.host,func.__name__,"not previously completed. Skipping..."])
else:
results = func(*args, **kwargs)
verbose =''
if results: set_version_state(func.__name__,object=results)
else: set_version_state(func.__name__)
return results
if env.verbosity and verbose: print verbose
return
return decorated | {
"repo_name": "bretth/woven",
"path": "woven/decorators.py",
"copies": "1",
"size": "2333",
"license": "bsd-3-clause",
"hash": -5339528897823658000,
"line_mean": 36.6451612903,
"line_max": 96,
"alpha_frac": 0.6099442778,
"autogenerated": false,
"ratio": 4.40188679245283,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.019246762903710687,
"num_lines": 62
} |
from functools import wraps
from fabric import api
def multisite(func):
"""
Mark a task as being multisite.
Multisite tasks allow you to define a global configuration for multiple
sites and specify the site to use when you run your command. All the
dictionary keys of the given site will then be made available in the `env`
variable. The structure is
`env.sites[site_name][env_name][configuration_key] = configuration_value`,
where `env_name` is the name of the decorated function. Also the decorated
function must take a parameter `site`.
Here's an example with sites A and B, both having prod and staging
environments::
env.sites = {
'site_a': {
'prod': {
'project_root': '/var/www/site_a/prod/'
},
'staging': {
'project_root': '/var/www/site_a/staging/'
}
},
'site_b': {
'prod': {
'project_root': '/var/www/site_b/prod/'
},
'staging': {
'project_root': '/var/www/site_b/staging/'
}
}
}
@task
@multisite
def prod(site):
# You could also define hosts in the `env.sites` dictionary if
# they're different from one site to another
# If the site is set to `site_a`, the decorator will take the
# contents from env.sites['site_a']['prod'] and make it available
# in the `env` variable
env.hosts = ['www.my_host.com']
@task
@multisite
def staging(site):
# You could also define hosts in the `env.sites` dictionary if
# they're different from one site to another
env.hosts = ['staging.my_host.com']
"""
if 'sites' not in api.env:
raise RuntimeError("To use the multisite decorator you need to set the"
" `env.sites` variable.")
@wraps(func)
def wrapper(*args, **kwargs):
if args:
site = args[0]
elif func.__defaults__:
site = func.__defaults__[0]
else:
site = None
selected_environment = func.__name__
if site is not None:
if site not in api.env.sites:
raise Exception(
"Site {site} is not part of the possible sites ({sites})"
.format(site=site, sites=api.env.sites.keys())
)
if selected_environment not in api.env.sites[site]:
raise Exception(
"Site {site} has no {env} environment"
.format(site=site, env=selected_environment)
)
for setting, value in api.env.sites[site][selected_environment].iteritems():
api.env[setting] = value
api.env.site = site
return func(*args, **kwargs)
return wrapper
| {
"repo_name": "liip/fabliip",
"path": "fabliip/decorators.py",
"copies": "2",
"size": "3028",
"license": "mit",
"hash": -1923773055763521000,
"line_mean": 31.9130434783,
"line_max": 88,
"alpha_frac": 0.5231175694,
"autogenerated": false,
"ratio": 4.492581602373887,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6015699171773887,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import abort, flash
from flask_security import current_user
from .models import db
def access_required(func):
""" This decorator ensures that the current user is logged in before calling the actual view.
Calls the unauthorized_view_function() when the user is not logged in."""
@wraps(func)
def decorated_view(*args, **kwargs):
# User must be authenticated
if not current_user.has_role('ADMIN'):
if not current_user.is_user(kwargs.get('id')):
# Redirect to unauthenticated page
abort(401)
# Call the actual view
return func(*args, **kwargs)
return decorated_view
def admin_required(func):
""" This decorator ensures that the current user is logged in before calling the actual view.
Calls the unauthorized_view_function() when the user is not logged in."""
@wraps(func)
def decorated_view(*args, **kwargs):
# User must be authenticated
if not current_user.is_admin(kwargs.get('id')):
# Redirect to unauthenticated page
abort(401)
# Call the actual view
return func(*args, **kwargs)
return decorated_view
class Bracket:
def __init__(self, players):
self.players = players
@property
def bracket(self):
rounds = self.players//2
round_pairings = [[n+1, self.players-(n)] for n in range(rounds)]
while rounds > 2:
rounds //= 2
prev_round = round_pairings
round_pairings = [[prev_round[n], prev_round.pop()] for n in range(rounds)]
return round_pairings | {
"repo_name": "ianzimmerman/gifoff",
"path": "gifoff/helpers.py",
"copies": "1",
"size": "1698",
"license": "mit",
"hash": 5487742283059357000,
"line_mean": 28.8070175439,
"line_max": 97,
"alpha_frac": 0.6142520612,
"autogenerated": false,
"ratio": 4.365038560411311,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5479290621611311,
"avg_score": null,
"num_lines": null
} |
# from functools import wraps
# from flask import (abort, flash, redirect, render_template, request, session,
# url_for)
# from flask.ext.login import (current_user, login_required, login_user,
# logout_user)
# from flask.ext.simon import get_or_404
# import when
# from . import app
# from .forms import LoginForm, ProfileForm, RegisterForm
# from .models import Event, User, login_manager
# def guest_required(f):
# @wraps(f)
# def _inner(*args, **kwargs):
# if current_user.is_authenticated():
# return redirect(url_for('.index'))
# return f(*args, **kwargs)
# return _inner
# @app.route('/event/<string:slug>')
# @login_required
# def event(slug):
# event = get_or_404(Event, slug=slug)
# if current_user.id not in event.users:
# abort(403)
# if 'events' in current_user:
# takers = current_user.events.get(str(event.id))['takers']
# recipients = [User.get(id=id) for id in takers]
# return render_template('events/index.html', event=event,
# recipients=recipients)
# @app.route('/')
# @login_required
# def index():
# now = when.now(utc=True)
# events = Event.find(users=current_user.id, active=True,
# begins__lte=now, ends__gt=now)
# if len(events) == 1:
# return redirect(url_for('.event', slug=events[0].slug))
# return render_template('index.html', events=events)
# @app.route('/login/', methods=('GET', 'POST'))
# @guest_required
# def login():
# form = LoginForm(request.form)
# if form.validate_on_submit():
# login_user(form.user)
# return redirect(request.args.get('next') or url_for('.index'))
# return render_template('login.html', form=form)
# @app.route('/logout')
# @login_required
# def logout():
# logout_user()
# return redirect(url_for('.index'))
# @app.route('/profile', methods=('GET', 'POST'))
# @login_required
# def profile():
# form = ProfileForm(request.form, **current_user._document)
# if form.validate_on_submit():
# current_user.update(**form.data)
# flash('Your profile has been updated.', 'success')
# return redirect(url_for('.profile'))
# return render_template('profile.html', form=form)
# @app.route('/register', methods=('GET', 'POST'))
# @guest_required
# def register():
# form = RegisterForm(request.form)
# if form.validate_on_submit():
# user = User(**form.data)
# user.set_password(str(form.password.data))
# user.save()
# login_user(user)
# flash('Thank you for signing up.')
# return redirect(request.args.get('next') or url_for('.index'))
# return render_template('register.html', form=form)
# @app.route('/event/<string:slug>/wishlist')
# @login_required
# def wishlist(slug):
# event = get_or_404(Event, slug=slug)
# if current_user.id not in event.users:
# abort(403)
# return render_template('events/wishlist.html', event=event)
# @login_manager.unauthorized_handler
# def login_prompt():
# session['login_redirect'] = request.path
# return redirect(url_for('.login'))
# from .admin import *
| {
"repo_name": "dirn/Secret-Santa",
"path": "xmas/views.py",
"copies": "1",
"size": "3241",
"license": "bsd-3-clause",
"hash": -4442660427337287000,
"line_mean": 27.4298245614,
"line_max": 79,
"alpha_frac": 0.6096883678,
"autogenerated": false,
"ratio": 3.231306081754736,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4340994449554736,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import abort, g, request, Response
from twilio.util import RequestValidator
from calloncongress.helpers import read_context
from calloncongress import settings
def twilioify(validate=True):
"""
Decorator that validates Twilio calls and creates the call context in the request.
"""
def decorator(func):
@wraps(func)
def decorated(*args, **kwargs):
print request.values
if 'CallSid' not in request.values:
return abort(401, 'Request must be a signed Twilio request.')
if validate and False:
validator = RequestValidator(settings.TWILIO_AUTH_TOKEN)
sig_header = request.headers.get('X-Twilio-Signature', '')
if request.method == 'POST':
vparams = request.form
vurl = request.url
else:
vparams = {}
vurl = request.url
# validator params are called URL, POST vars, and signature
if not validator.validate(vurl, vparams, sig_header):
return abort(401, 'Request signature could not be validated')
# load the call from Mongo or create if one does not exist
g.call = load_call(request.values['CallSid'], request.values)
g.zipcode = read_context('zipcode', None)
g.legislator = read_context('legislator', None)
twilio_response = func(*args, **kwargs)
return Response(str(twilio_response), mimetype='application/xml')
return decorated
return decorator
def validate_before(*args):
"""
Decorator that makes sure required callbacks have been run and appropriate values provided.
"""
dependencies = args
def decorator(func):
@wraps(func)
def decorated(*args, **kwargs):
for dep in dependencies:
valid = dep()
if valid is not True:
return str(valid)
return func(*args, **kwargs)
return decorated
return decorator
def load_call(sid, params):
""" Loads a call from the datastore or creates a new one if one
does not exist. Appends the current call status to the list
of requests involved in this call.
sid: the unique call ID from Twilio
params: the POSTed request parameters
"""
# find existing call
doc = g.db.calls.find_one({'call_sid': sid})
if doc is None:
# create new call if call does not exist
doc = {
'call_sid': sid,
'from': params['From'],
'to': params['To'],
'caller_name': params.get('CallerName', None),
'context': {
'zipcode': None,
'legislator': None,
},
'language': '',
}
g.db.calls.insert(doc)
# create array for requests list
if 'requests' not in doc:
doc['requests'] = []
# append current request information and update current status
doc['requests'].append({
'timestamp': g.now,
'call_status': params['CallStatus']
})
doc['current_status'] = params['CallStatus']
return doc
| {
"repo_name": "sunlightlabs/calloncongress",
"path": "calloncongress/decorators.py",
"copies": "1",
"size": "3283",
"license": "bsd-3-clause",
"hash": 4814583191028089000,
"line_mean": 29.119266055,
"line_max": 95,
"alpha_frac": 0.5735607676,
"autogenerated": false,
"ratio": 4.553398058252427,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5626958825852427,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import abort, request, redirect
from flask_login import current_user, login_url
from sqlalchemy.orm.exc import NoResultFound
from app import login_manager, sentry
from app.constants import permission
from app.models import (
Users,
Responses,
Files,
Notes,
Letters,
Links,
Instructions,
Determinations,
Envelopes
)
def has_permission(permission: int):
"""
Checks to see if the current_user has the appropriate permission for this endpoint.
:param f: View function that is being wrapped.
:param permissions: List of permission values.
:return:
"""
def decorator(f):
@wraps(f)
def decorated_function(request_id, *args, **kwargs):
if not current_user.is_authenticated or current_user.is_anonymous:
return redirect(login_url(login_manager.login_view,
next_url=request.url))
return f(request_id) if is_allowed(user=current_user, request_id=request_id,
permission=permission) else abort(403)
return decorated_function
return decorator
def has_super():
"""
Checks to see if the current_user is a super user.
:param f: Function that is being wrapped.
:return:
"""
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not getattr(current_user, 'is_super', False):
return abort(403)
return f(*args, **kwargs)
return decorated_function
return decorator
def is_allowed(user: Users, request_id: str, permission: int):
"""
:param user:
:param request_id:
:param permissions:
:return:
"""
try:
user_request = user.user_requests.filter_by(request_id=request_id).one()
return True if user_request.has_permission(permission) else False
except NoResultFound:
sentry.captureException()
return False
except AttributeError:
sentry.captureException()
return False
def get_permission(permission_type: str, response_type: Responses):
"""
:param permission_type:
:param response_type:
:return:
"""
if response_type not in [Determinations, Envelopes, Letters]:
if permission_type == 'edit':
permission_for_edit_type = {
Files: permission.EDIT_FILE,
Notes: permission.EDIT_NOTE,
Instructions: permission.EDIT_OFFLINE_INSTRUCTIONS,
Links: permission.EDIT_LINK,
}
return permission_for_edit_type[response_type]
if permission_type == 'privacy':
permission_for_edit_type_privacy = {
Files: permission.EDIT_FILE_PRIVACY,
Notes: permission.EDIT_NOTE_PRIVACY,
Instructions: permission.EDIT_OFFLINE_INSTRUCTIONS_PRIVACY,
Links: permission.EDIT_LINK_PRIVACY
}
return permission_for_edit_type_privacy[response_type]
if permission_type == 'delete':
permission_for_delete_type = {
Files: permission.DELETE_FILE,
Notes: permission.DELETE_NOTE,
Instructions: permission.DELETE_OFFLINE_INSTRUCTIONS,
Links: permission.DELETE_LINK
}
return permission_for_delete_type[response_type]
return 0
| {
"repo_name": "CityOfNewYork/NYCOpenRecords",
"path": "app/lib/permission_utils.py",
"copies": "1",
"size": "3480",
"license": "apache-2.0",
"hash": -5540344306193414000,
"line_mean": 27.5245901639,
"line_max": 88,
"alpha_frac": 0.6077586207,
"autogenerated": false,
"ratio": 4.339152119700748,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0003817473558107049,
"num_lines": 122
} |
from functools import wraps
from flask import Blueprint, current_app, render_template, redirect, request, url_for, flash, session, abort, jsonify
from flask_login import current_user, login_required
from sqlalchemy import or_, and_
from preston.xmlapi import Preston as XMLAPI
from auth.shared import db, eveapi
from auth.models import User
from .models import Member
from .reddit_oauth import RedditOAuth
# Create and configure app
app = Blueprint('hr', __name__, template_folder='templates/hr', static_folder='static')
# Reddit OAuth connection
reddit_oauth = None
# Storage for API calls
new_apps = []
@app.record_once
def _record(setup_state):
app.config = setup_state.app.config
global reddit_oauth
reddit_oauth = RedditOAuth(
app.config['REDDIT_OAUTH_CLIENT_ID'],
app.config['REDDIT_OAUTH_SECRET'],
app.config['REDDIT_OAUTH_CALLBACK']
)
@app.context_processor
def _prerender():
if current_user.is_authenticated:
return {
'member': Member.query.filter_by(character_name=current_user.name).first()
}
return {}
@app.before_request
def _preprocess():
member = get_member_for(current_user)
if not current_user.is_anonymous:
if not member:
id = get_id_for_name(current_user.name)
db.session.add(Member(current_user.name, id, get_corp_for_id(id)))
db.session.commit()
elif not member.character_id:
member.character_id = get_id_for_name(member.character_name)
db.session.commit()
@app.route('/', methods=['GET', 'POST'])
@login_required
def index():
"""
Member page.
This is for logged in members to view their personal data. They
can edit the API keys.
Methods:
GET
POST
Args:
None
Returns:
rendered template 'personal.html'
"""
if get_member_for(current_user).status in ['Guest', 'New', 'Ready to be interviewed', 'Ready to be accepted']:
return redirect(url_for('.join'))
if request.method == 'POST':
current_app.logger.debug('POST on index by {}'.format(current_user.name))
key_id = request.form['key_id']
v_code = request.form['v_code']
validate_key(key_id, v_code, get_member_for(current_user))
return redirect(url_for('.index'))
reddit_link = reddit_oauth.get_authorize_url()
return render_template('hr/personal.html', reddit_link=reddit_link)
def validate_key(key_id, v_code, member):
"""
This method validates a single- or multi-line string of API
keys and codes separated by ' - ' against the EVE API to
verify that they have the correct access mask.
Args:
key_id (str) - EVE API key keyID
v_code (str) - EVE API key vCode
member (hr.models.Member) - Member to update if the keys are valid
Returns:
value (bool) if all keys were valid
"""
errors = []
try:
auth = XMLAPI(key=key_id, code=v_code, user_agent=eveapi['user_agent'])
result = auth.account.APIKeyInfo()
if not int(result['key']['@accessMask']) == app.config['API_KEY_MASK']:
errors.append('The key with ID "{}" has the wrong access mask. Has: {}, needs: {}'.format(
key_id, result['key']['@accessMask'], app.config['API_KEY_MASK']
))
except Exception as e:
errors.append('An error occurred with keyID "{}"'.format(key_id))
errors.append('An error occurred with keyID "{}": {}'.format(key_id, str(e)))
if not errors and member:
member.key_id = key_id
member.v_code = v_code
db.session.commit()
flash('API key information saved', 'success')
else:
flash('; '.join(errors), 'error')
return not errors
@app.route('/members')
@login_required
def membership():
"""
Recruiter page.
This page shows recruiters the total list of members of the corporation
and the applications to join the corporation.
Args:
None
Returns:
rendered template 'membership.html'
"""
if not current_user.recruiter and not current_user.mentor and not current_user.admin:
return redirect(url_for('.index'))
show_hidden = request.args.get('show_hidden', 0, type=bool)
show_applications = request.args.get('show_applications', 0, type=bool)
members = Member.query.filter_by(hidden=show_hidden).all()
if show_applications:
members = [member for member in members if member.status in
['New', 'Ready to be interviewed', 'Ready to be accepted']]
members = sorted(members, key=lambda x: x.character_name.lower())
return render_template('hr/membership.html',
members=members, show_hidden=show_hidden, show_applications=show_applications)
@app.route('/members/add', methods=['GET', 'POST'])
@login_required
def add_member():
"""
This page allows recruiters to manually add an applicant.
Methods:
GET
POST
Args:
None
Returns:
rendered template 'add_applicant.html'
"""
if not current_user.recruiter and not current_user.admin:
return redirect(url_for('.index'))
if request.method == 'POST':
name = request.form.get('name')
reddit = request.form.get('reddit')
status = request.form.get('status')
apikey = request.form.get('apikey')
apicode = request.form.get('apicode')
main = request.form.get('main')
if main == '*':
main = name
notes = request.form.get('notes')
current_app.logger.debug('POST on add_member by {}: name = {}, reddit = {}, status = {}, main = {}'.format(
current_user.name, name, reddit, status, main
))
if not validate_key(apikey, apicode, None):
current_app.logger.info('POST on add_member didn\'t have a valid key')
flash('Invalid key for user', 'danger')
return redirect(url_for('.add_member'))
id = get_id_for_name(name)
member = Member(name, id, get_corp_for_id(id), status, reddit, main, notes, apikey, apicode)
current_app.logger.info('New member added through add_member: ' + str(name))
db.session.add(member)
db.session.commit()
db.session.commit()
flash('Character added', 'success')
return render_template('hr/add_member.html', all_members=get_all_member_names())
@app.route('/admin', methods=['GET', 'POSt'])
@login_required
def admin():
"""
This is the admin control page, where admins can add and remove
recruiters and pull all corp members from the EVE API to update
the database.
Methods:
GET
POST
Args:
None
Returns:
rendered template 'admin.html'
"""
if not current_user.admin:
current_app.logger.debug('Admin access denied to {}'.format(current_user.name))
return redirect(url_for('.index'))
if request.method == 'POST':
current_app.logger.debug('POST on admin by {}'.format(current_user.name))
name = request.form['name']
member = Member.query.filter_by(character_name=name).first()
if not member:
flash('Unknown member', 'error')
return redirect(url_for('.admin'))
member.status = 'Accepted'
if request.form['role'] == 'Recruiter':
member.user.recruiter = True
if request.form['role'] == 'Mentor':
member.user.mentor = True
db.session.commit()
flash(member.character_name + ' promoted to ' + request.form['role'], 'success')
return redirect(url_for('.admin'))
admins = ', '.join([user.name for user in User.query.filter_by(admin=True).all()])
recruiters = [get_member_for(user) for user in User.query.filter(or_(User.recruiter, User.admin)).all()]
mentors = [get_member_for(user) for user in User.query.filter(or_(User.mentor, User.admin)).all()]
recruiters = sorted(set(recruiters), key=lambda x: x.character_name)
mentors = sorted(set(mentors), key=lambda x: x.character_name)
return render_template('hr/admin.html',
admins=admins, recruiters=recruiters, mentors=mentors, all_members=get_all_member_names())
@app.route('/admin/set_status', methods=['POST'])
@login_required
def admin_set_status():
"""
This transient endpoint allows an admin to set the
status of a member.
Methods:
POST
Args:
None
Returns:
redirect to the admin endpoint
"""
if not current_user.admin:
return redirect(url_for('.index'))
if not request.method == 'POST':
return redirect(url_for('.admin'))
name = request.form.get('name', None)
status = request.form.get('status', 'New')
if not name or not status:
flash('Missing name or status', 'error')
return redirect(url_for('.admin'))
member = Member.query.filter_by(character_name=name).first()
if not member:
flash('Unknown member name', 'error')
return redirect(url_for('.admin'))
member.status = status
db.session.commit()
flash('User status changed for ' + name + ' to ' + status, 'success')
return redirect(url_for('.admin'))
@app.route('/admin/revoke/<name>/<role>')
@login_required
def revoke_access(name, role):
"""
This transient endpoint allows an admin to revoke the recruiter
status of a member.
Args:
name (str) - name of the recruiter to revoke
Returns:
redirect to the admin endpoint
"""
if not current_user.admin:
return redirect(url_for('.index'))
member = Member.query.filter_by(character_name=name).first()
if not member:
flash('Unknown member name', 'error')
return redirect(url_for('.admin'))
member.status = 'Accepted'
if role == 'Recruiter':
member.user.recruiter = False
elif role == 'Mentor':
member.user.mentor = False
db.session.commit()
flash('User access revoked for ' + name, 'success')
return redirect(url_for('.admin'))
@app.route('/details/<int:id>', methods=['GET', 'POST'])
@login_required
def details(id):
"""
This page allows recruiters to view and edit a member's details.
Methods:
GET
POST
Args:
id (int) - id of the member to examine
Returns:
rendered template 'details.html'
"""
if not current_user.recruiter and not current_user.mentor and not current_user.admin:
current_app.logger.debug('Details access denied to {}'.format(current_user.name))
return redirect(url_for('.index'))
member = Member.query.get(id)
if not member:
flash('Unknown id', 'error')
current_app.logger.error('Unknown id on details for id {} by {}'.format(id, current_user.name))
return redirect(url_for('.membership'))
if request.method == 'POST':
if request.form['section'] == 'keys':
current_app.logger.info('POST on details - keys by {} for {}'.format(
current_user.name, member.character_name
))
validate_key(request.form['key_id'], request.form['v_code'], member)
elif request.form['section'] == 'status':
current_app.logger.info('POST on details - status by {} for {}: {}'.format(
current_user.name, member.character_name, request.form['status']
))
member.status = request.form['status']
if member.status == 'Denied':
member.hidden = True
db.session.commit()
flash('Status changed', 'success')
elif request.form['section'] == 'main':
current_app.logger.info('POST on details - main by {} for {}: {}'.format(
current_user.name, member.character_name, request.form['main']
))
main = request.form['main']
member.main = main if not main == '*' else member.character_name
db.session.commit()
flash('Main character changed', 'success')
elif request.form['section'] == 'notes':
current_app.logger.info('POST on details - notes by {} for {}: {}'.format(
current_user.name, member.character_name, request.form['notes']
))
member.notes = request.form['notes']
db.session.commit()
flash('Notes changed', 'success')
elif request.form['section'] == 'training':
current_app.logger.info('POST on details - training by {} for {}'.format(
current_user.name, member.character_name
))
member.know_good_fits = 'know_good_fits' in request.form
member.know_scan = 'know_scan' in request.form
member.know_mass_and_time = 'know_mass_and_time' in request.form
member.know_organize_gank = 'know_organize_gank' in request.form
member.know_when_to_pve = 'know_when_to_pve' in request.form
member.know_comms = 'know_comms' in request.form
member.know_appropriate_ships = 'know_appropriate_ships' in request.form
member.know_intel = 'know_intel' in request.form
member.know_pvp = 'know_pvp' in request.form
member.know_doctrine = 'know_doctrine' in request.form
for alt in member.get_alts():
alt.know_good_fits = member.know_good_fits
alt.know_scan = member.know_scan
alt.know_mass_and_time = member.know_mass_and_time
alt.know_organize_gank = member.know_organize_gank
alt.know_when_to_pve = member.know_when_to_pve
alt.know_comms = member.know_comms
alt.know_appropriate_ships = member.know_appropriate_ships
alt.know_intel = member.know_intel
alt.know_pvp = member.know_pvp
alt.know_doctrine = member.know_doctrine
db.session.commit()
else:
flash('Unknown form submission', 'error')
return redirect(url_for('.details', id=id))
return render_template('hr/details.html', member=member, all_members=get_all_member_names())
@app.route('/visibility/<int:id>/<action>')
@login_required
def visibility(id, action):
"""
This transient endpoint allows a recruiter to set the visiblity
of a member on the membership page (to be used to hide people who
have left the corp).
Args:
id (int) - id of the member to modify
action (str) - whether to hide or show the member
Returns:
redirect to the member's details endpoint
"""
if not current_user.recruiter and not current_user.admin:
current_app.logger.debug('Visibility access denied to {}'.format(current_user.name))
return redirect(url_for('.index'))
member = Member.query.get(id)
if not member:
flash('Unknown id', 'error')
current_app.logger.error('Unknown id on details for id {} by {}'.format(id, current_user.name))
return redirect(url_for('.membership'))
member.hidden = action == 'hide'
db.session.commit()
flash('"{}" {}'.format(member.character_name, 'hidden' if member.hidden else 'made visible'), 'success')
return redirect(url_for('.details', id=id))
@app.route('/delete/<int:id>')
@login_required
def delete(id):
"""
This transient endpoint allows an admin to permanently delete a
member from the database.
Args:
id (int) - id of the member to delete
Returns:
redirect to the membership endpoint
"""
if not current_user.admin:
current_app.logger.debug('Delete access denied to {}'.format(current_user.name))
return redirect(url_for('.details', id=id))
Member.query.filter_by(id=id).delete()
db.session.commit()
flash('Member deleted', 'success')
return redirect(url_for('.membership'))
@app.route('/join', methods=['GET', 'POST'])
@login_required
def join():
"""
This page allows a user to submit an application to join the corporation
by supplying an API key and optional reddit account and main character.
Methods:
GET
POST
Args:
None
Returns:
rendered template 'join.html'
"""
member = get_member_for(current_user)
if member.status == 'Accepted':
return redirect(url_for('.index'))
character_name = session.get('character_name') or current_user.name if not current_user.is_anonymous else None
if not character_name:
flash('Well, something went wrong. Try again?', 'error')
return redirect(url_for('.login'))
if request.method == 'POST':
current_app.logger.debug('POST on join by {}'.format(current_user.name))
try:
key = request.form['key']
code = request.form['code']
auth = XMLAPI(key=key, code=code, user_agent=eveapi['user_agent'])
main = request.form.get('main')
reddit = None
if main == '*':
main = get_member_for(current_user).character_name
else:
try:
reddit = Member.query.filter_by(character_name=main).first().reddit
except Exception:
current_app.logger.warning('{} tried to set {} as their main, but that Member object wasn\'t found'.format(
current_user.name, main
))
result = auth.account.APIKeyInfo()
if not int(result['key']['@accessMask']) == app.config['API_KEY_MASK']:
flash('Wrong key mask - you need {}'.format(app.config['API_KEY_MASK']), 'error')
return redirect(url_for('.join'))
member = get_member_for(current_user)
member.status = 'New'
member.main = main
member.key_id = key
member.v_code = code
member.reddit = reddit
db.session.commit()
new_apps.append(current_user.name)
flash('Your application is in - someone will take a look soon', 'success')
except Exception:
flash('An error occurred when parsing your API key. Are you sure you entered it right?', 'error')
return redirect(url_for('.join'))
reddit_link = reddit_oauth.get_authorize_url()
return render_template('hr/join.html',
character_name=character_name, reddit_link=reddit_link,
all_members=get_all_member_names(), discord_link=app.config['DISCORD_LINK'])
@app.route('/sync')
@login_required
def sync():
"""
This transient endpoint calls the sync_members method.
Args:
None
Returns:
redirect to the admin endpoint
"""
if not current_user.admin:
current_app.logger.debug('Admin access denied to {}'.format(current_user.name))
return redirect(url_for('.index'))
sync_members()
return redirect(url_for('.admin'))
def sync_members():
"""
This method allows an admin to import a list of corporation
members from the EVE API, updating any missing models from the database
and marking characters that have left (or been kicked from) the corporation
as being gone.
Args:
None
Returns:
value (dict) of membership changes
"""
current_app.logger.info('-- Starting member sync')
auth = XMLAPI(
key=app.config['CORP_MEMBER_API_KEY'],
code=app.config['CORP_MEMBER_API_CODE'],
user_agent=eveapi['user_agent']
)
api_members = []
existing_members, new_members, left_members = [], [], []
for member in auth.corp.MemberTracking()['rowset']['row']:
name = member['@name']
db_model = Member.query.filter_by(character_name=name).first()
if not db_model:
current_app.logger.info('-- Added {} to the corporation'.format(name))
existing_members.append(name)
db_model = Member(name, member['@characterID'], app.config['CORPORATION'], 'Accepted')
db.session.add(db_model)
db_model.corporation = app.config['CORPORATION']
if db_model.status not in ['Accepted', 'Recruiter']:
db_model.status = 'Accepted'
new_members.append(name)
current_app.logger.info('-- {} has been accepted into the corporation'.format(name))
api_members.append(name)
current_app.logger.debug('Full corp roster: ' + ', '.join(api_members))
for member in Member.query.filter_by(status='Accepted').all():
if member.character_name not in api_members:
current_app.logger.warning('-- ' + member.character_name + ' is not in the corporation')
left_members.append(member.character_name)
if member.user:
db.session.delete(member.user)
db.session.delete(member)
try:
db.session.commit()
current_app.logger.info('-- Database saved after member sync')
except Exception as e:
current_app.logger.error('-- An error occurred when syncing members: ' + str(e))
flash('Members imported', 'success')
return {
'existing_members': existing_members,
'new_members': new_members,
'left_members': left_members
}
@app.route('/reports')
@login_required
def reports():
"""
This page shows reports to the recruiters for the purpose of validation
and security.
Args:
None
Returns:
Rendered template 'reports.html'
"""
if not current_user.recruiter and not current_user.admin:
current_app.logger.debug('Visibility access denied to {}'.format(current_user.name))
return redirect(url_for('.index'))
members = Member.query.filter(and_(Member.status != 'Left', Member.status != 'Guest')).all()
member_names = get_all_member_names()
defunct_alts = []
invalid_mains = []
missing_api_keys = []
for member in members:
if member.character_name != member.main:
if member.main not in member_names:
invalid_mains.append(member)
else:
main = [m for m in members if m.character_name == member.main]
if (len(main) > 0 and main[0].status == 'Left') or not main:
defunct_alts.append(member)
if not member.key_id or not member.v_code:
missing_api_keys.append(member)
return render_template('hr/reports.html',
defunct_alts=defunct_alts, invalid_mains=invalid_mains, missing_api_keys=missing_api_keys)
@app.route('/reddit/callback')
@login_required
def reddit_oauth_callback():
"""
This transient endpoint completes the reddit OAuth verification process
and sets the current user's reddit account in the database.
Args:
None
Returns:
redirect to the index endpoint
"""
if current_user.is_anonymous:
return redirect(url_for('.login'))
current_app.logger.debug('Reddit callback by {}'.format(current_user.name))
username = reddit_oauth.get_token(request.args['code'])
user_member = get_member_for(current_user)
user_member.reddit = username
current_app.logger.info('{} updated their reddit account to {}'.format(current_user.name, username))
for member in Member.query.filter_by(main=user_member.character_name).all():
member.reddit = username
current_app.logger.info('{} updated their alt {} reddit account to {}'.format(
current_user.name, member.character_name, username
))
db.session.commit()
return redirect(url_for('.index'))
def api_key_required(f):
@wraps(f)
def inner(*args, **kwargs):
"""
Endpoint decorator for REST interactions - the request
header must contain the secret from the config.
Args:
args (tuple) - args
kwargs (dict) - kwargs
Returns:
call of the wrapped method if the header was valid, a
error 403 response otherwise
"""
token = request.headers.get('REST-SECRET')
if not token or not token == app.config['REST_SECRET']:
current_app.logger.warning('Access denied to API endpoint ' + str(request.endpoint) + ', token = ' + str(token))
abort(403)
return f(*args, **kwargs)
return inner
@app.route('/api/sync')
@api_key_required
def api_sync():
"""
Syncs the corporation membership with the EVE XML API
and returns the result of doing so.
Args:
None
Returns:
response (JSON)
"""
current_app.logger.info('API endpoint sync accessed')
return jsonify(sync_members())
@app.route('/api/apps')
@api_key_required
def api_apps():
"""
Returns a list of all new apps since the last poll.
Args:
None
Returns:
response (JSON)
"""
current_app.logger.info('API endpoint apps accessed')
apps = new_apps
new_apps.clear()
return jsonify(apps)
@app.route('/api/keys')
@api_key_required
def api_keys():
"""
Iterates through all API keys in the database and checks that
they're still valid. Since API keys are validated when entered
and cannot be removed from the system without being switched
for another valid pair, the only way that a user can block
access to their data through the EVE XML API is deleting the
key from their account. There's no notification for this, so
keys have to be checked periodically.
To reduce the amount of API calls, members who've already
left the corporation are not checked.
Args:
None
Returns:
response (JSON)
"""
current_app.logger.info('API endpoint keys accessed')
invalid_keys = []
for member in Member.query.filter(Member.status != 'Left').all():
try:
auth = XMLAPI(key=member.key_id, code=member.v_code, user_agent=eveapi['user_agent'])
result = auth.account.APIKeyInfo()
if not int(result['key']['@accessMask']) == app.config['API_KEY_MASK']:
invalid_keys.append(member.character_name)
current_app.logger.warning('-- ' + member.character_name + ' has an invalid API key!')
else:
current_app.logger.debug('-- ' + member.character_name + ' has a valid API key')
except Exception:
invalid_keys.append(member.character_name)
current_app.logger.warning('-- ' + member.character_name + ' has an invalid API key!')
return jsonify(invalid_keys)
def get_all_member_names():
"""
Returns a list of all member names in the corporation.
Args:
None
Returns:
value (list) of string names
"""
return sorted([m.character_name for m in Member.query.all()], key=lambda x: x.lower())
def get_id_for_name(name):
"""
This helper method takes a character's name and returns their EVE character ID.
Args:
name (str): character name
Returns:
int: character id
"""
return eveapi['xml'].eve.CharacterId(names=name)['rowset']['row']['@characterID']
def get_corp_for_name(name):
"""
This helper method takes a character's name and returns their corporation.
Args:
name (str) - full character name
Returns:
value (int) of their EVE character ID
"""
return get_corp_for_id(get_id_for_name(name))
def get_corp_for_id(id):
"""
This helper method takes a character's id and returns their corporation name.
Args:
name (str) - full character name
Returns:
value (str) of their corporation's name
"""
return eveapi['xml'].eve.CharacterAffiliation(ids=id)['rowset']['row']['@corporationName']
def get_member_for(user):
"""
This helper method returns the corresponding Member object for the user.
Args:
user (User): the user
Returns:
Member: member object if there's a user logged in, otherwise None
"""
if current_user.is_anonymous:
return None
return Member.query.filter_by(character_name=user.name).first()
| {
"repo_name": "Celeo/GETIN-Auth",
"path": "auth/hr/app.py",
"copies": "1",
"size": "28095",
"license": "mit",
"hash": -6048206060843003000,
"line_mean": 33.9440298507,
"line_max": 127,
"alpha_frac": 0.6168001424,
"autogenerated": false,
"ratio": 3.8666391412056154,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9978276465403346,
"avg_score": 0.0010325636404537612,
"num_lines": 804
} |
from functools import wraps
from flask import Blueprint
from flask import current_app as app # noqa
from flask import redirect, render_template, request, url_for
from flask_login import LoginManager, current_user, login_user, logout_user
from flask_wtf import Form
from sqlalchemy import func
from wtforms import PasswordField, TextField
from wtforms.validators import DataRequired
from .database import db_session
from .models import User
auth = Blueprint("auth", __name__)
login_manager = LoginManager()
class LoginForm(Form):
email = TextField("email", validators=[DataRequired()])
password = PasswordField("password", validators=[DataRequired()])
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.user = None
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = (
db_session.query(User)
.filter(
func.lower(User.email) == func.lower(self.email.data),
User.role.in_(["admin", "callcenter"]),
)
.first()
)
if user is None:
self.email.errors.append("Email address is not registered")
return False
if not user.check_password(user.email, self.password.data):
self.password.errors.append("Password is not valid")
return False
self.user = user
return True
@login_manager.user_loader
def load_user(userid):
return db_session.query(User).get(userid)
@login_manager.unauthorized_handler
def handle_needs_login():
return redirect(url_for("auth.login", next=request.path))
@auth.route("/login/", methods=["GET", "POST"])
def login():
form = LoginForm()
if form.validate_on_submit():
user = form.user
login_user(user)
redirect_next = url_for("views.index")
if request.args.get("next"):
redirect_next = request.args.get("next")
return redirect(redirect_next)
email = form.email.data
return render_template("login.html", form=form, email=email)
@auth.route("/logout/")
def logout():
logout_user()
return redirect(url_for("auth.login"))
def admin_required(f):
"""Restrict view to users with 'admin' role"""
@wraps(f)
def decorated_function(*args, **kwargs):
if current_user is None or current_user.role != "admin":
return redirect(url_for("auth.login", next=request.url))
return f(*args, **kwargs)
return decorated_function
| {
"repo_name": "MetroTenants/squared_away_reporter",
"path": "reporter/auth.py",
"copies": "1",
"size": "2552",
"license": "mit",
"hash": -3032293216430010400,
"line_mean": 26.7391304348,
"line_max": 75,
"alpha_frac": 0.6347962382,
"autogenerated": false,
"ratio": 3.9261538461538463,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 92
} |
from functools import wraps
from flask import Blueprint, render_template, request
from flask.ext.restful import abort, fields, reqparse, marshal_with, Resource
from flask.ext.security import current_user
from .core import api, db
from .models import Actor, Character, Series
from .utils import fields_from_model
bp = Blueprint('index', __name__)
@bp.route('/')
def index():
return render_template('index/index.html')
actor_fields = fields_from_model(Actor)
series_fields = fields_from_model(Series)
character_fields = fields_from_model(Character)
character_fields['actor'] = fields.Nested(actor_fields)
character_fields['series'] = fields.Nested(series_fields)
actor_parser = reqparse.RequestParser()
actor_parser.add_argument('name', type=str, required=True)
series_parser = reqparse.RequestParser()
series_parser.add_argument('name', type=str, required=True)
series_parser.add_argument('debut_year', type=int, required=True)
character_parser = reqparse.RequestParser()
character_parser.add_argument('name', type=str, required=True)
character_parser.add_argument('actor_id', type=int, required=True)
character_parser.add_argument('series_id', type=int, required=True)
def auth_to_modify(func):
@wraps(func)
def wrapper(*args, **kwargs):
if (request.method in ('POST', 'PUT', 'DELETE') and
not current_user.is_authenticated()):
abort(401)
return func(*args, **kwargs)
return wrapper
class ActorDetailResource(Resource):
method_decorators = [marshal_with(actor_fields), auth_to_modify]
def get(self, actor_id):
return Actor.query.get_or_404(actor_id)
def delete(self, actor_id):
actor = Actor.query.get(actor_id)
if actor:
db.session.delete(actor)
db.session.commit()
return '', 204
def put(self, actor_id):
args = actor_parser.parse_args()
actor = Actor.query.get(actor_id)
if not actor:
actor = Actor(id=actor_id)
db.session.add(actor)
actor.name = args['name']
db.session.commit()
return actor
class ActorListResource(Resource):
method_decorators = [marshal_with(actor_fields), auth_to_modify]
def get(self):
return Actor.query.all()
def post(self):
args = actor_parser.parse_args()
actor = Actor(**args)
db.session.add(actor)
db.session.commit()
return actor
class SeriesDetailResource(Resource):
method_decorators = [marshal_with(series_fields), auth_to_modify]
def get(self, series_id):
return Series.query.get_or_404(series_id)
def delete(self, series_id):
series = Series.query.get(series_id)
if series:
db.session.delete(series)
db.session.commit()
return '', 204
def put(self, series_id):
args = series_parser.parse_args()
series = Series.query.get(series_id)
if not series:
series = Series(id=series_id)
db.session.add(series)
series.name = args['name']
series.debut_year = args['debut_year']
db.session.commit()
return series
class SeriesListResource(Resource):
method_decorators = [marshal_with(series_fields), auth_to_modify]
def get(self):
return Series.query.all()
def post(self):
args = series_parser.parse_args()
series = Series(**args)
db.session.add(series)
db.session.commit()
return series
class CharacterDetailResource(Resource):
method_decorators = [marshal_with(character_fields), auth_to_modify]
def get(self, character_id):
return Character.query.get_or_404(character_id)
def delete(self, character_id):
character = Character.query.get(character_id)
if character:
db.session.delete(character)
db.session.commit()
return '', 204
def put(self, character_id):
args = character_parser.parse_args()
character = Character.query.get(character_id)
if not character:
character = Character(id=character_id)
db.session.add(character)
character.name = args['name']
character.actor_id = args['actor_id']
character.series_id = args['series_id']
db.session.commit()
return character
class CharacterListResource(Resource):
method_decorators = [marshal_with(character_fields), auth_to_modify]
def get(self):
return Character.query.all()
def post(self):
args = character_parser.parse_args()
character = Character(**args)
db.session.add(character)
db.session.commit()
return character
api.add_resource(ActorListResource, '/actors/')
api.add_resource(ActorDetailResource, '/actors/<int:actor_id>/')
api.add_resource(SeriesListResource, '/series/')
api.add_resource(SeriesDetailResource, '/series/<int:series_id>/')
api.add_resource(CharacterListResource, '/characters/')
api.add_resource(CharacterDetailResource, '/characters/<int:character_id>/')
| {
"repo_name": "jonafato/ivadb",
"path": "ivadb/views.py",
"copies": "1",
"size": "5092",
"license": "bsd-3-clause",
"hash": -6778747540117080000,
"line_mean": 28.7777777778,
"line_max": 77,
"alpha_frac": 0.6535742341,
"autogenerated": false,
"ratio": 3.7249451353328458,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.48785193694328455,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import Blueprint, url_for, request
from uchan.lib import roles
from uchan.lib.action_authorizer import NoPermissionError
from uchan.lib.moderator_request import request_has_role, get_authed
mod = Blueprint('mod', __name__, url_prefix='/mod', template_folder='templates', static_folder='static')
def mod_role_restrict(role):
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not request_has_role(role):
raise NoPermissionError()
return f(*args, **kwargs)
return decorated_function
return decorator
@mod.context_processor
def inject_variables():
if get_authed():
mod_links = [
('boards', ['mod.mod_boards', 'mod.mod_board_log']),
('reports', ['mod.mod_report'])
]
if request_has_role(roles.ROLE_ADMIN):
mod_links += [
('bans', ['mod.mod_bans']),
('moderators', ['mod.mod_moderators']),
('pages', ['mod.mod_pages']),
('site', ['mod.mod_site']),
]
mod_links += [
('account', ['mod.mod_self']),
('logout', ['mod.mod_auth'])
]
with_current_and_url = []
for mod_link in mod_links:
current = any(i.startswith(request.endpoint) for i in mod_link[1])
with_current_and_url.append((mod_link[0], url_for(mod_link[1][0]), current))
return dict(
mod_links=with_current_and_url,
is_authed=True
)
else:
return {}
import uchan.view.mod.mod_auth
import uchan.view.mod.mod_report
import uchan.view.mod.mod_self
import uchan.view.mod.mod_board
import uchan.view.mod.mod_moderator
import uchan.view.mod.mod_site
import uchan.view.mod.mod_bans
import uchan.view.mod.mod_page
| {
"repo_name": "Floens/uchan",
"path": "uchan/view/mod/__init__.py",
"copies": "1",
"size": "1873",
"license": "mit",
"hash": -4358888981313848000,
"line_mean": 26.9552238806,
"line_max": 104,
"alpha_frac": 0.5851575013,
"autogenerated": false,
"ratio": 3.5608365019011408,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.46459940032011404,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, abort, request
def requires_debug(view):
@wraps(view)
def _(*args, **kwargs):
strict = not current_app.config.get('FLASK_DEBUG_DISABLE_STRICT',
False)
if not current_app.debug:
if strict:
abort(404) # don't even show we have flask-debug installed
abort(403, 'This function is only available if the application '
'has been started in debug mode.')
msg = []
if strict:
# extra security checks
msg = []
strict_env = {
'SERVER_NAME': '127.0.0.1',
'REMOTE_ADDR': '127.0.0.1',
'SERVER_PORT': '5000',
}
for env, val in strict_env.items():
if request.environ.get(env, None) != val:
msg.append('{} is not {!r}.'
.format(env, val))
if not request.environ.get('SERVER_SOFTWARE', '').startswith(
'Werkzeug/'
):
msg.append('Not running on Werkzeug-Server.')
if 'X-Forwarded-For' in request.headers:
msg.append('Request has a X-Forwarded-For header.')
if msg:
msg.append('Strict security checks are enabled, to prevent '
'security issues in case you have forgotten to '
'disable debugging on a production system. You '
'can disable these by setting '
'FLASK_DEBUG_DISABLE_STRICT to True '
'in your applications configuration.')
if msg:
abort(403, '\n\n'.join(msg))
return view(*args, **kwargs)
return _
| {
"repo_name": "mbr/Flask-Debug",
"path": "flask_debug/security.py",
"copies": "1",
"size": "1860",
"license": "mit",
"hash": 4075692500568659000,
"line_mean": 34.7692307692,
"line_max": 76,
"alpha_frac": 0.4822580645,
"autogenerated": false,
"ratio": 4.685138539042821,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 52
} |
from functools import wraps
from flask import current_app, g, session as cookie_session
from flask_login import current_user
from flask_themes2 import render_theme_template
from structlog import get_logger
from app.globals import get_metadata, get_session_timeout_in_seconds
from app.templating.metadata_context import build_metadata_context
from app.templating.template_renderer import TemplateRenderer
from app.authentication.no_token_exception import NoTokenException
logger = get_logger()
def with_session_timeout(func):
@wraps(func)
def session_wrapper(*args, **kwargs):
session_timeout = get_session_timeout_in_seconds(g.schema)
return func(
*args,
session_timeout=session_timeout,
**kwargs
)
return session_wrapper
def with_metadata_context(func):
@wraps(wraps)
def metadata_context_wrapper(*args, **kwargs):
metadata = get_metadata(current_user)
if not metadata:
raise NoTokenException(401)
metadata_context = build_metadata_context(metadata)
return func(*args, metadata_context=metadata_context, **kwargs)
return metadata_context_wrapper
def with_analytics(func):
@wraps(func)
def analytics_wrapper(*args, **kwargs):
return func(
*args,
analytics_gtm_id=current_app.config['EQ_GTM_ID'],
analytics_gtm_env_id=current_app.config['EQ_GTM_ENV_ID'],
**kwargs)
return analytics_wrapper
def with_questionnaire_url_prefix(func):
@wraps(func)
def url_prefix_wrapper(*args, **kwargs):
metadata = get_metadata(current_user)
metadata_context = build_metadata_context(metadata)
url_prefix = '/questionnaire/{}/{}/{}'.format(
metadata_context['eq_id'],
metadata_context['form_type'],
metadata_context['collection_id'],
)
return func(*args, url_prefix=url_prefix, **kwargs)
return url_prefix_wrapper
def with_legal_basis(func):
@wraps(func)
def legal_basis_wrapper(*args, **kwargs):
legal_basis = g.schema.json.get('legal_basis')
return func(*args, legal_basis=legal_basis, **kwargs)
return legal_basis_wrapper
def render_template(template, **kwargs):
theme = g.schema.json.get('theme')
template = '{}.html'.format(template).lower()
return render_theme_template(
theme,
template,
survey_title=TemplateRenderer.safe_content(g.schema.json['title']),
account_service_url=cookie_session.get('account_service_url'),
account_service_log_out_url=cookie_session.get('account_service_log_out_url'),
survey_id=g.schema.json['survey_id'],
survey_guidance_url=g.schema.json.get('survey_guidance_url'),
**kwargs
)
| {
"repo_name": "ONSdigital/eq-survey-runner",
"path": "app/helpers/template_helper.py",
"copies": "1",
"size": "2812",
"license": "mit",
"hash": 1052785185171291300,
"line_mean": 28.914893617,
"line_max": 86,
"alpha_frac": 0.6614509246,
"autogenerated": false,
"ratio": 3.846785225718194,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5008236150318194,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, jsonify
from flask_jwt import (
_jwt_required, _default_request_handler, current_identity, JWTError)
from qlutter_todo.extensions import bcrypt
from qlutter_todo.models.user import User
def authenticate(email, password):
user = User.get_by_email(email)
if user and bcrypt.check_password_hash(user.password.encode('utf-8'),
password.encode('utf-8')):
return user
def identity(payload):
user_id = payload['identity']
return User.get_by_id(user_id)
def auth_response_handler(access_token, user):
access_token = access_token.decode('utf-8')
user.add_token(access_token)
return jsonify({'access_token': access_token})
def auth_required(fn):
@wraps(fn)
def decorator(*args, **kwargs):
_jwt_required(current_app.config['JWT_DEFAULT_REALM'])
token = _default_request_handler()
user = current_identity
if not user.verify_token(token):
raise JWTError('Bad request', 'Invalid token')
return fn(*args, **kwargs)
return decorator
def logout(user):
token = _default_request_handler()
user.remove_token(token)
| {
"repo_name": "pkolios/qlutter-todo",
"path": "qlutter_todo/auth/utils.py",
"copies": "1",
"size": "1221",
"license": "mit",
"hash": -8176238634338875000,
"line_mean": 27.3953488372,
"line_max": 73,
"alpha_frac": 0.6617526618,
"autogenerated": false,
"ratio": 3.688821752265861,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.48505744140658613,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, redirect, request, session
from oic import rndstr
from oic.oic.message import EndSessionRequest
from werkzeug.exceptions import BadRequest
def authenticate(view_fn):
@wraps(view_fn)
def wrapper(*args, **kwargs):
if _reauthentication_necessary():
current_app.logger.info(
'Redirecting to {idp} for authentication'.format(
idp=current_app.config['OIDC_CLIENT']['issuer']))
return _authenticate()
return view_fn(*args, **kwargs)
return wrapper
def _reauthentication_necessary():
return session.get('id_token') is None
def _authenticate():
session.update({
'destination': request.url,
'state': rndstr(),
'nonce': rndstr()
})
return redirect(_authentication_request())
def _authentication_request():
client = current_app.extensions['oidc_client'].client
auth_req = client.construct_AuthorizationRequest(
request_args={
'client_id': client.client_id,
'response_type': 'code',
'scope': ['openid', 'profile'],
'redirect_uri': client.registration_response['redirect_uris'][0],
'state': session['state'],
'nonce': session['nonce'],
'kc_idp_hint': session.get(
'idp_hint', request.args.get('idp_hint')),
'login_hint': session.get('email_address'),
'claims': {
'id_token': {
'email': None,
'name': None
},
'userinfo': {
'email': {'essential': True},
'name': {'essential': True}
}
}
}
)
return auth_req.request(client.authorization_endpoint)
def logout(view_fn):
current_app.extensions['oidc_client'].logout_view = view_fn
@wraps(view_fn)
def wrapper(*args, **kwargs):
id_token_jwt = session['id_token_jwt']
if not _is_logout_redirect_callback():
current_app.logger.info('Clearing session')
session.clear()
url = _provider_logout_url(id_token_jwt)
if url:
current_app.logger.info('Logging out of IDP')
return redirect(url, 303)
return view_fn(*args, **kwargs)
return wrapper
def _is_logout_redirect_callback():
state = request.args.get('state')
is_redirect = state is not None
if is_redirect and state != session.pop('end_session_state'):
raise BadRequest('Mismatched state')
return is_redirect
def _provider_logout_url(id_token_jwt):
client = current_app.extensions['oidc_client']
endpoint = client.client.provider_info.get('end_session_endpoint')
logout_urls = client.client_registration_info['post_logout_redirect_uris']
if not endpoint:
return None
session['end_session_state'] = rndstr()
end_session_request = EndSessionRequest(
id_token_hint=id_token_jwt,
post_logout_redirect_uri=logout_urls[0],
state=session['end_session_state'])
return end_session_request.request(endpoint)
| {
"repo_name": "crossgovernmentservices/sue-my-brother",
"path": "app/oidc_client/decorators.py",
"copies": "1",
"size": "3209",
"license": "mit",
"hash": -799577294563918800,
"line_mean": 26.4273504274,
"line_max": 78,
"alpha_frac": 0.5864755376,
"autogenerated": false,
"ratio": 4.056890012642225,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5143365550242225,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, request
from itsdangerous import URLSafeSerializer
from app.mod_api.errors import InvalidUsage
def valid_facility(f):
"""A decorator to return a 404 if the facilitry is not there.
:param f: Function to decorate.
:type f: function
:return: Decorated function.
:rtype: function
"""
@wraps(f)
def decorated_function(*args, **kwargs):
if 'facility' in kwargs.keys():
if kwargs['facility'] not in current_app.facilities.keys():
raise InvalidUsage('facility not found', status_code=404)
return f(*args, **kwargs)
return decorated_function
def valid_token(f):
"""A decorator to check if there is a token and if its valid.
:param f: Function to decorate.
:type f: function
:return: Decorated function.
:rtype: function
"""
@wraps(f)
def decorated_function(*args, **kwargs):
s = URLSafeSerializer(current_app.config['SECRET_KEY'],
salt=kwargs['facility'])
if 'token' not in request.args:
raise InvalidUsage('no token', status_code=401)
try:
s.loads(request.args.get('token'))
except:
raise InvalidUsage('bad token', status_code=401)
return f(*args, **kwargs)
return decorated_function
| {
"repo_name": "xsteadfastx/bib-api",
"path": "app/mod_api/decorators.py",
"copies": "1",
"size": "1372",
"license": "mit",
"hash": 6815000623235580000,
"line_mean": 25.3846153846,
"line_max": 73,
"alpha_frac": 0.6253644315,
"autogenerated": false,
"ratio": 4.083333333333333,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001201923076923077,
"num_lines": 52
} |
from functools import wraps
from flask import current_app, request
from .allows import allows
__all__ = ("requires", "exempt_from_requirements", "guard_entire")
def _get_executing_handler():
return current_app.view_functions[request.endpoint]
def _should_run_requirements():
if request.routing_exception is not None:
return False
return not getattr(_get_executing_handler(), "__allows_exempt__", False)
def requires(*requirements, **opts):
"""
Standalone decorator to apply requirements to routes, either function
handlers or class based views::
@requires(MyRequirement())
def a_view():
pass
class AView(View):
decorators = [requires(MyRequirement())]
:param requirements: The requirements to apply to this route
:param throws: Optional. Exception or exception instance to throw if
authorization fails.
:param on_fail: Optional. Value or function to use when authorization
fails.
:param identity: Optional. An identity to use in place of the currently
loaded identity.
"""
identity = opts.get("identity")
on_fail = opts.get("on_fail")
throws = opts.get("throws")
def decorator(f):
@wraps(f)
def allower(*args, **kwargs):
result = allows.run(
requirements,
identity=identity,
on_fail=on_fail,
throws=throws,
f_args=args,
f_kwargs=kwargs,
)
# authorization failed
if result is not None:
return result
return f(*args, **kwargs)
return allower
return decorator
def exempt_from_requirements(f):
"""
Used to exempt a route handler from ambient requirement handling unless it
is explicitly decorated with a requirement runner::
@bp.route('/')
@exempt_from_requirements
def greeting_area():
return "Hello!"
To use with a class based view, apply it to the class level decorators
attribute::
class SomeCBV(View):
decorators = [exempt_from_requirements]
def get(self):
return "Hello!"
.. note::
You cannot exempt individual methods of a class based view with this
decorator, e.g. the follow will not work::
class SomeCBV(MethodView):
@exempt_from_requirements
def get(self):
return "Hello!"
Any permissioning applied at the blueprint level would still affect
this route.
:param f: The route handler to be decorated.
.. versionadded:: 0.7.0
"""
f.__allows_exempt__ = True
return f
def guard_entire(requirements, identity=None, throws=None, on_fail=None):
"""
Used to protect an entire blueprint with a set of requirements. If a route
handler inside the blueprint should be exempt, then it may be decorated
with the :func:`~flask_allows.views.exempt_from_requirements` decorator.
This function should be registered as a before_request handler on the
blueprint and provided with the requirements to guard the blueprint with::
my_bp = Blueprint(__name__, 'namespace')
my_bp.before_request(guard_entire(MustBeLoggedIn()))
``identity``, ``on_fail`` and ``throws`` may also be provided but are optional.
If on_fails returns a non-None result, that will be considered the return
value of the routing::
from flask import flash, redirect
def flash_and_redirect(message, level, endpoint):
def _(*a, **k):
flash(message, level)
return redirect(endpoint)
return _
bp = Blueprint(__name__, 'namespace')
bp.before_request(
guard_entire(
[MustBeLoggedIn()],
on_fail=flash_and_redirect(
"Please login in first",
"warning",
"login"
)
)
)
``on_fail`` will also receive anything found in
``flask.request.view_args`` as keyword arguments.
If needed, this guard may be applied multiple times. This may be useful
if different conditions should result in different `on_fail` mechanisms
being invoked::
bp = Blueprint(__name__, "admin_panel")
bp.before_request(
guard_entire(
[MustBeLoggedIn()],
on_fail=flash_and_redirect(
"Please login in first",
"warning",
"login"
)
)
)
bp.before_request(
guard_entire(
[MustBeAdmin()],
on_fail=flash_and_redirect(
"You are not an admin.",
"danger",
"index"
)
)
)
:param requirements: An iterable of requirements to apply to every request
routed to the blueprint.
:param identity: Optional. The identity that should be used for fulfilling
requirements on the blueprint level.
:param throws: Optional. Exception or exception type to be thrown if
authorization fails.
:param on_fail: Optional. Value or function to use if authorization fails.
.. versionadded: 0.7.0
"""
def guarder():
if _should_run_requirements():
return allows.run(
requirements,
identity=identity,
on_fail=on_fail,
throws=throws,
f_kwargs=request.view_args,
)
return None
return guarder
| {
"repo_name": "justanr/flask-allows",
"path": "src/flask_allows/views.py",
"copies": "1",
"size": "5753",
"license": "mit",
"hash": -5603187767303640000,
"line_mean": 27.3399014778,
"line_max": 83,
"alpha_frac": 0.5758734573,
"autogenerated": false,
"ratio": 4.719442165709598,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00005864414731409805,
"num_lines": 203
} |
from functools import wraps
from flask import current_app, request
from itsdangerous import BadSignature, SignatureExpired, TimestampSigner
from trexmo.core.db.models import User
from trexmo.core.exc import ExpiredTokenError, InvalidTokenError, PrivilegeError
def parse_auth():
"""Parse the authentication token attached to the request.
This function tries to retrieve the authentication token attached to the
request by. It first looks for `X-Auth-Token` in the request headers. If
no such header could be found, it checks for `Auth-Token` in the request
cookies.
The function returns the owner UID associated with the token attached to
the request, or raises an exception if none of these locations contains a
valid one.
:raises ~trexmo.core.exc.InvalidTokenError:
if the given token is missing or invalid.
:raises ~trexmo.core.exc.ExpiredTokenError:
if the given token expired.
"""
auth_token = request.headers.get('X-Auth-Token', request.cookies.get('Auth-Token'))
if auth_token is None:
raise InvalidTokenError()
signer = TimestampSigner(current_app.secret_key)
try:
auth = signer.unsign(auth_token, max_age=current_app.config['AUTH_TOKEN_DURATION'])
except BadSignature:
raise InvalidTokenError()
except SignatureExpired:
raise ExpiredTokenError()
return auth.decode()
def require_auth(f):
"""A decorator that is used on views to ensure that a valid authentication
token was attached to the request. The decorated function is called with
the user UID obtained from the token as an additional argument.
.. note::
The decorator raises a token exception if the authentication token is
either missing or invalid, without calling the decorated function.
"""
@wraps(f)
def wrapper(*args, **kwargs):
# Get and validate the auth token.
auth = parse_auth()
# Append the owner UID to the function arguments and call it.
kwargs['auth'] = auth
return f(*args, **kwargs)
return wrapper
def require_root_auth(f):
"""A decorator that is used on views to ensure that a valid authentication
token was attached to the request, and that it is associated with a root
user.
.. seealso:: func:`require_auth`
"""
@wraps(f)
def wrapper(*args, **kwargs):
# Get and validate the auth token.
auth = parse_auth()
# Make sure the associated user is a root.
user = User.query.filter(User.uid == auth).first()
if (user is None) or (not user.root):
raise PrivilegeError()
# Append the owner UID to the function arguments and call it.
kwargs['auth'] = auth
return f(*args, **kwargs)
return wrapper
def make_auth_token(auth_user):
"""Generates an authentication token for the given user."""
signer = TimestampSigner(current_app.secret_key)
return signer.sign(str(auth_user.uid)).decode()
| {
"repo_name": "kyouko-taiga/trexmo",
"path": "trexmo/core/utils/auth.py",
"copies": "1",
"size": "3013",
"license": "apache-2.0",
"hash": -3344817518674191000,
"line_mean": 31.3978494624,
"line_max": 91,
"alpha_frac": 0.68503153,
"autogenerated": false,
"ratio": 4.243661971830986,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5428693501830986,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, url_for, g, request
from social.utils import module_member, setting_name
from social.strategies.utils import get_strategy
DEFAULTS = {
'STORAGE': 'social.apps.flask_me_app.models.FlaskStorage',
'STRATEGY': 'social.strategies.flask_strategy.FlaskStrategy'
}
def get_helper(name, do_import=False):
config = current_app.config.get(setting_name(name),
DEFAULTS.get(name, None))
return do_import and module_member(config) or config
def load_strategy(*args, **kwargs):
backends = get_helper('AUTHENTICATION_BACKENDS')
strategy = get_helper('STRATEGY')
storage = get_helper('STORAGE')
return get_strategy(backends, strategy, storage, *args, **kwargs)
def strategy(redirect_uri=None):
def decorator(func):
@wraps(func)
def wrapper(backend, *args, **kwargs):
uri = redirect_uri
if uri and not uri.startswith('/'):
uri = url_for(uri, backend=backend)
g.strategy = load_strategy(request=request, backend=backend,
redirect_uri=uri, *args, **kwargs)
return func(backend, *args, **kwargs)
return wrapper
return decorator
| {
"repo_name": "duoduo369/python-social-auth",
"path": "social/apps/flask_me_app/utils.py",
"copies": "2",
"size": "1279",
"license": "bsd-3-clause",
"hash": 5814834186077399000,
"line_mean": 31.7948717949,
"line_max": 73,
"alpha_frac": 0.6372165754,
"autogenerated": false,
"ratio": 3.984423676012461,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5621640251412462,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import current_app, url_for, g, request, redirect
from social.utils import module_member, setting_name
from social.strategies.utils import get_strategy
DEFAULTS = {
'STORAGE': 'social.apps.flask_app.models.FlaskStorage',
'STRATEGY': 'social.strategies.flask_strategy.FlaskStrategy'
}
def get_helper(name, do_import=False):
config = current_app.config.get(setting_name(name),
DEFAULTS.get(name, None))
return do_import and module_member(config) or config
def load_strategy(*args, **kwargs):
backends = get_helper('AUTHENTICATION_BACKENDS')
strategy = get_helper('STRATEGY')
storage = get_helper('STORAGE')
return get_strategy(backends, strategy, storage, *args, **kwargs)
def strategy(redirect_uri=None):
def decorator(func):
@wraps(func)
def wrapper(backend, *args, **kwargs):
uri = redirect_uri
if uri and not uri.startswith('/'):
uri = url_for(uri, backend=backend)
g.strategy = load_strategy(request=request, backend=backend,
redirect_uri=uri, *args, **kwargs)
return func(backend, *args, **kwargs)
return wrapper
return decorator
def login_required(fn):
@wraps(fn)
def decorated_view(*args, **kwargs):
if not g.user.is_authenticated:
return redirect('/')
return fn(*args, **kwargs)
return decorated_view
| {
"repo_name": "dongweiming/flask_reveal",
"path": "social/apps/flask_app/utils.py",
"copies": "1",
"size": "1501",
"license": "bsd-3-clause",
"hash": -748781485152460700,
"line_mean": 30.9361702128,
"line_max": 73,
"alpha_frac": 0.6315789474,
"autogenerated": false,
"ratio": 3.992021276595745,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5123600223995745,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import Flask
from flask import jsonify
from flask_jwt_extended import create_access_token
from flask_jwt_extended import get_jwt
from flask_jwt_extended import JWTManager
from flask_jwt_extended import verify_jwt_in_request
app = Flask(__name__)
app.config["JWT_SECRET_KEY"] = "super-secret" # Change this!
jwt = JWTManager(app)
# Here is a custom decorator that verifies the JWT is present in the request,
# as well as insuring that the JWT has a claim indicating that this user is
# an administrator
def admin_required():
def wrapper(fn):
@wraps(fn)
def decorator(*args, **kwargs):
verify_jwt_in_request()
claims = get_jwt()
if claims["is_administrator"]:
return fn(*args, **kwargs)
else:
return jsonify(msg="Admins only!"), 403
return decorator
return wrapper
@app.route("/login", methods=["POST"])
def login():
access_token = create_access_token(
"admin_user", additional_claims={"is_administrator": True}
)
return jsonify(access_token=access_token)
@app.route("/protected", methods=["GET"])
@admin_required()
def protected():
return jsonify(foo="bar")
if __name__ == "__main__":
app.run()
| {
"repo_name": "vimalloc/flask-jwt-extended",
"path": "examples/custom_decorators.py",
"copies": "1",
"size": "1288",
"license": "mit",
"hash": -6676005405439362000,
"line_mean": 24.2549019608,
"line_max": 77,
"alpha_frac": 0.6529503106,
"autogenerated": false,
"ratio": 3.788235294117647,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9941185604717646,
"avg_score": 0,
"num_lines": 51
} |
from functools import wraps
from flask import Flask, render_template, redirect, request
from google.appengine.api import users
from models import Person
def render_login_template(template, **kwargs):
user = users.get_current_user()
if user:
login_url = users.create_logout_url(request.url)
url_linktext = 'logout'
else:
login_url = users.create_login_url(request.url)
url_linktext = 'login'
return render_template(template, login_url=login_url, url_linktext=url_linktext, **kwargs)
def with_person(func):
@wraps(func)
def decorated_view(*args, **kwargs):
google_user = users.get_current_user()
if google_user is not None:
google_id = google_user.user_id()
person = Person.with_google_id(google_id)
if person is None:
return redirect("/")
else:
return func(*args, person=person, **kwargs)
else:
raise Exception("no google user in new_person")
return decorated_view
| {
"repo_name": "augment00/a00_registry",
"path": "src/shared.py",
"copies": "1",
"size": "1047",
"license": "mit",
"hash": 6025024351126661000,
"line_mean": 29.7941176471,
"line_max": 94,
"alpha_frac": 0.629417383,
"autogenerated": false,
"ratio": 3.906716417910448,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5036133800910448,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import (Flask, render_template, request, redirect, url_for,
flash, make_response, jsonify)
from flask import session as login_session
from sqlalchemy import create_engine, asc
from sqlalchemy.orm import sessionmaker
from database_setup import (Base, User, Catalog, Category, Record,
Field, RecordTemplate, FieldTemplate, Option)
from oauth2client.client import flow_from_clientsecrets
from oauth2client.client import FlowExchangeError
import random, string, httplib2, json, requests
app = Flask(__name__)
APPLICATION_NAME = "Catalogizer"
# client id for google openID
CLIENT_ID = json.loads(open(
'client_secrets.json', 'r').read())['web']['client_id']
engine = create_engine('sqlite:///catalogizer.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
def login_required(f):
# Needed for decoraters to update __name__ and __module__
@wraps(f)
def decorated_function(*args, **kwargs):
if 'user_id' not in login_session:
return redirect('/login')
return f(*args, **kwargs)
return decorated_function
@app.route('/login/')
def show_login():
state = ''.join(random.choice(
string.ascii_uppercase + string.digits) for x in xrange(32))
login_session['state'] = state
if 'gplus_id' in login_session:
flash('You are already logged in.', 'error')
return redirect('/')
if 'facebook_id' in login_session:
flash('You are already logged in.', 'error')
return redirect('/')
return render_template('login.html', STATE=state)
@app.route('/gconnect', methods=['Post'])
def gconnect():
if request.args.get('state') != login_session.get('state'):
response = make_response(json.dumps('Invalid state parameter'), 401)
response.headers['Content-Type'] = 'application/json'
return response
code = request.data
try:
# Upgrade the authorization code into a credentials object that can be
# used to authorize requests.
oauth_flow = flow_from_clientsecrets('client_secrets.json', scope='')
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except FlowExchangeError:
response = make_response(json.dumps(
'Failed to upgrade the authorization code.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Check that the access token is valid.
access_token = credentials.access_token
url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s'
% access_token)
h = httplib2.Http()
result = json.loads(h.request(url, 'GET')[1])
# If there was an error in the access token info, abort.
if result.get('error') is not None:
response = make_response(json.dumps(result.get('error')), 500)
response.headers['Content-Type'] = 'application/json'
# Verify that the acces token is used for the intendend user.
gplus_id = credentials.id_token['sub']
if result['user_id'] != gplus_id:
response = make_response(json.dumps(
"Token's user ID doesn't match given user ID."), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is valid for this app.
if result['issued_to'] != CLIENT_ID:
response = make_response(json.dumps(
"Token's client ID does not match app's"), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Check to see if user is already logged in.
stored_access_token = login_session.get('access_token')
stored_gplus_id = login_session.get('gplus_id')
if stored_access_token is not None and gplus_id == stored_gplus_id:
response = make_response(json.dumps(
"Current user is already connected."), 200)
response.headers['Content-Type'] = 'application/json'
return response
# Store the access token in the session for later use.
login_session['access_token'] = access_token
login_session['gplus_id'] = gplus_id
# Get user info
userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo"
params = {'access_token': access_token, 'alt': 'json'}
answer = requests.get(userinfo_url, params=params)
data = answer.json()
login_session['username'] = data['name']
login_session['picture'] = data['picture']
login_session['email'] = data['email']
# See if user exists and get ID assigned in database.
user_id = getUserID(login_session['email'])
if not user_id:
user_id = createUser(login_session)
login_session['user_id'] = user_id
updateUser(login_session['user_id'],
login_session['picture'],
login_session['username'])
output = ''
output += '<h1>Welcome, '
output += login_session['username']
output += '!</h1>'
output += '<img src="'
output += login_session['picture']
output += (' " style = "width: 300px; height: 300px;'
'border-radius: 150px;-webkit-border-radius: 150px'
';-moz-border-radius: 150px;"> ')
flash("Now logged in as %s" % login_session['username'])
print login_session
return output
@app.route('/fbconnect', methods=['POST'])
def fbconnect():
if request.args.get('state') != login_session['state']:
response = make_response(json.dumps('Invalid state parameter.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
access_token = request.data
app_id = json.loads(open(
'fb_client_secrets.json', 'r').read())['web']['app_id']
app_secret = json.loads(open(
'fb_client_secrets.json', 'r').read())['web']['app_secret']
url = ('https://graph.facebook.com/oauth/access_token?'
'grant_type=fb_exchange_token&client_id=%s&client_secret=%s&'
'fb_exchange_token=%s' % (app_id, app_secret, access_token))
h = httplib2.Http()
result = h.request(url, 'GET')[1]
# Use token to get user info from API
userinfo_url = "https://graph.facebook.com/v2.4/me"
# Strip expire tag from access token
token = result.split("&")[0]
url = userinfo_url + '?%s&fields=name,id,email' % token
h = httplib2.Http()
result = h.request(url, 'GET')[1]
data = json.loads(result)
login_session['username'] = data["name"]
login_session['email'] = data["email"]
login_session['facebook_id'] = data["id"]
# The token must be stored in the login_session in order to properly logout
# strip out the information before the equals sign in the token
stored_token = token.split("=")[1]
login_session['access_token'] = stored_token
# Get user picture
url = ('https://graph.facebook.com/v2.4/me/picture?'
'%s&redirect=0&height=200&width=200' % token)
h = httplib2.Http()
result = h.request(url, 'GET')[1]
data = json.loads(result)
login_session['picture'] = data["data"]["url"]
# see if user exists, create user if they don't, and get assigned id
user_id = getUserID(login_session['email'])
if not user_id:
user_id = createUser(login_session)
login_session['user_id'] = user_id
updateUser(login_session['user_id'],
login_session['picture'],
login_session['username'])
output = ''
output += '<h1>Welcome, '
output += login_session['username']
output += '!</h1>'
output += '<img src="'
output += login_session['picture']
output += (' " style = "width: 300px; height: 300px;'
'border-radius: 150px;-webkit-border-radius: 150px'
';-moz-border-radius: 150px;"> ')
flash("Now logged in as %s" % login_session['username'])
return output
# DISCONNECT - Revoke a current user's token and reset their login_session.
def gdisconnect():
access_token = login_session['access_token']
url = 'https://accounts.google.com/o/oauth2/revoke?token=%s' % access_token
h = httplib2.Http()
result = h.request(url, 'GET')[0]
if result['status'] == '200':
del login_session['access_token']
del login_session['gplus_id']
del login_session['username']
del login_session['email']
del login_session['picture']
del login_session['user_id']
flash('You have been sucessfully logged out')
return redirect(url_for('viewCatalogs'))
else:
response = make_response(json.dumps(
'Failed to revoke token for given user.', 400))
response.headers['Content-Type'] = 'application/json'
return response
def fbdisconnect():
access_token = login_session['access_token']
facebook_id = login_session['facebook_id']
url = 'https://graph.facebook.com/%s/\
permissions?access_token=%s' % (facebook_id, access_token)
h = httplib2.Http()
result = h.request(url, 'DELETE')[1]
print 'result is '
print result
if 'success' in result:
del login_session['access_token']
del login_session['facebook_id']
del login_session['username']
del login_session['email']
del login_session['picture']
del login_session['user_id']
flash('You have been sucessfully logged out')
return redirect(url_for('viewCatalogs'))
else:
response = make_response(json.dumps(
'Failed to revoke token for given user.', 400))
response.headers['Content-Type'] = 'application/json'
return response
@app.route("/disconnect/")
def disconnect():
if not login_session:
return redirect('/login')
access_token = login_session.get('access_token')
if access_token is None:
flash('You are not logged in', 'error')
return redirect(url_for('show_login'))
if 'gplus_id' in login_session:
return gdisconnect()
elif 'facebook_id' in login_session:
return fbdisconnect()
else:
return redirect('/login')
@app.route('/')
@app.route('/catalog/')
def viewCatalogs():
# print login_session
catalogs = getCatalogs()
return render_template('viewCatalogs.html',
catalogs=catalogs,
current_user=login_session.get('user_id'))
@app.route('/catalog/new/', methods=['GET', 'POST'])
@login_required
def newCatalog():
if request.method == 'POST':
catalogName = request.form['catalog-name']
newCatalogEntry = Catalog(name=catalogName,
user_id=login_session.get('user_id'))
try:
session.add(newCatalogEntry)
session.commit()
flash('%s successfully created!' % catalogName)
except:
session.rollback()
raise
return redirect(url_for('viewCatalogs'))
else:
return render_template('newCatalog.html')
@app.route('/catalog/<int:catalog_id>/edit/', methods=['GET', 'POST'])
@login_required
def editCatalog(catalog_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can edit this catalog.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
newCatalogName = request.form['new-catalog-name']
catalog.name = newCatalogName
try:
session.commit()
flash('%s successfully edited!' % newCatalogName)
except:
session.rollback()
raise
return redirect(url_for('viewCatalogs'))
else:
return render_template('editCatalog.html', catalog=catalog)
@app.route('/catalog/<int:catalog_id>/delete/', methods=['GET', 'POST'])
@login_required
def deleteCatalog(catalog_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can delete this catalog.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
delCatalog(catalog_id)
return redirect(url_for('viewCatalogs'))
else:
return render_template('deleteCatalog.html', catalog=catalog)
@app.route('/catalog/<int:catalog_id>/category/')
def viewCategories(catalog_id):
catalog = getCatalog(catalog_id)
categories = getCategories(catalog_id)
return render_template('viewCategories.html',
catalog=catalog,
categories=categories,
current_user=login_session.get('user_id'))
@app.route('/catalog/<int:catalog_id>/category/new', methods=['GET', 'POST'])
@login_required
def newCategory(catalog_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can add a category to it.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
categoryName = request.form['category-name']
categoryEntry = Category(name=categoryName, catalog_id=catalog.id)
try:
session.add(categoryEntry)
session.commit()
flash('%s successfully created!' % categoryName)
except:
session.rollback()
raise
return redirect(url_for('viewCategories', catalog_id=catalog.id))
else:
return render_template('newCategory.html', catalog=catalog)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/edit/',
methods=['GET', 'POST'])
@login_required
def editCategory(catalog_id, category_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can edit this category.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
category = getCategory(category_id)
if request.method == 'POST':
newCategoryName = request.form['new-category-name']
category.name = newCategoryName
try:
session.commit()
except:
session.rollback()
raise
flash('%s successfully edited!' % newCategoryName)
return redirect(url_for('viewCategories', catalog_id=catalog_id))
else:
return render_template('editCategory.html',
catalog=catalog,
category=category)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/delete/',
methods=['GET', 'POST'])
@login_required
def deleteCategory(catalog_id, category_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can delete this category.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
delCategory(category_id)
return redirect(url_for('viewCategories', catalog_id=catalog_id))
else:
category = getCategory(category_id)
return render_template('deleteCategory.html',
catalog=catalog,
category=category)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/')
def viewRecords(catalog_id, category_id):
catalog = getCatalog(catalog_id)
category = getCategory(category_id)
records = getRecordsByCategoryId(category_id)
return render_template('viewRecords.html',
catalog=catalog,
category=category,
records=records,
current_user=login_session.get('user_id'))
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/add/')
@login_required
def addRecord(catalog_id, category_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can add a new record to it.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
category = getCategory(category_id)
recordTemplates = getRecordTemplates(category_id)
return render_template('addRecord.html',
catalog=catalog,
category=category,
rTemplates=recordTemplates,
current_user=login_session.get('user_id'))
# Over 80 characters, however URL Routes break if they go to new line.
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/add/<int:record_template_id>/new/', methods=['GET', 'POST'])
@login_required
def newRecord(catalog_id, category_id, record_template_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can add a new record to it.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
recordName = request.form['record-name']
addNewRecord(category_id, record_template_id)
flash('%s successfully created!' % recordName)
return redirect(url_for('viewRecords',
catalog_id=catalog_id,
category_id=category_id))
else:
category = getCategory(category_id)
recordTemplate = getRecordTemplate(record_template_id)
fieldTemplatesWithOptions = getFormattedFieldTemplatesWithOptions(
record_template_id)
return render_template('newRecord.html',
catalog=catalog,
category=category,
rTemplate=recordTemplate,
fTemplates=fieldTemplatesWithOptions)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/<int:record_id>/edit/', methods=['GET', 'POST'])
@login_required
def editRecord(catalog_id, category_id, record_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can edit this record.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
record = getRecord(record_id)
if request.method == 'POST':
newName = request.form['record-name']
record_template_id = record.record_template_id
delRecord(record_id)
addNewRecord(category_id, record_template_id)
flash('%s successfully edited!' % newName)
return redirect(url_for('viewRecords',
catalog_id=catalog_id,
category_id=category_id))
else:
category = getCategory(category_id)
fieldTemplatesWithValues = getFieldTemplatesWithValues(record_id)
return render_template('editRecord.html',
catalog=catalog,
category=category,
record=record,
fTemplates=fieldTemplatesWithValues)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/<int:record_id>/delete/', methods=['GET', 'POST'])
@login_required
def deleteRecord(catalog_id, category_id, record_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can delete this record.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
record = getRecord(record_id)
flash('%s successfully deleted!' % record.name)
delRecord(record_id)
return redirect(url_for('viewRecords',
catalog_id=catalog_id,
category_id=category_id))
else:
category = getCategory(category_id)
record = getRecord(record_id)
return render_template('deleteRecord.html',
catalog=catalog,
category=category,
record=record)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/<int:record_id>/view/')
def showRecord(catalog_id, category_id, record_id):
catalog = getCatalog(catalog_id)
category = getCategory(category_id)
record = getRecord(record_id)
fields = getFormattedFields(record_id)
return render_template('showRecord.html',
catalog=catalog,
category=category,
record=record,
fields=fields)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/add/template/', methods=['GET', 'POST'])
@login_required
def newRecordTemplate(catalog_id, category_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can add a record template for it.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
# werkzeug returns an immutable object. Using .copy() creates a mutable
# copy.
formData = request.form.copy()
# Pop recordTemplateName as it has a different format than the other
# values, and goes in a seperate table.
recordTemplateName = formData.pop('template-name')
recordTemplateEntry = RecordTemplate(name=recordTemplateName,
category_id=category_id)
try:
session.add(recordTemplateEntry)
session.commit()
except:
session.rollback()
raise
# Iterate over form inputs, placing labels and field kind inside the
# FieldTemplate table, and options within the Option table.
for keyValue in formData.lists():
# Each field template has a 'label' and a field 'kind',
# which may or may not have 'options' assigned to it.
# They are grouped together by a group identifier number at
# the beginning of the field name (before the first hyphen).
groupIdentifier = keyValue[0][0:keyValue[0].find("-")]
inputType = keyValue[0][keyValue[0].find("-") + 1:]
# For each of the inputs with the name "field-kind",
# find their label and options using the group identifier and
# add them to their respective tables.
if inputType == "field-kind":
fieldTemplateLabel = formData.get(
groupIdentifier + "-field-label")
fieldTemplateKind = formData.get(
groupIdentifier + "-field-kind")
fieldTemplateOptions = formData.getlist(
groupIdentifier + "-option")
fieldTemplateEntry = FieldTemplate(
label=fieldTemplateLabel,
kind=fieldTemplateKind,
order=groupIdentifier,
record_template_id=recordTemplateEntry.id)
try:
session.add(fieldTemplateEntry)
session.commit()
except:
session.rollback()
raise
while len(fieldTemplateOptions) > 0:
optionEntry = Option(
name=fieldTemplateOptions.pop(0),
field_template_id=fieldTemplateEntry.id)
try:
session.add(optionEntry)
session.commit()
except:
session.rollback()
raise
flash('%s successfully created!' % recordTemplateName)
return redirect(url_for('addRecord',
catalog_id=catalog_id,
category_id=category_id))
else:
category = getCategory(category_id)
return render_template('recordTemplate.html',
catalog=catalog,
category=category)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/add/template/<int:record_template_id>/edit/', methods=['GET', 'POST'])
@login_required
def editRecordTemplate(catalog_id, category_id, record_template_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can edit this record template.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
rTemplate = getRecordTemplate(record_template_id)
if request.method == 'POST':
newRecordTemplateName = request.form['new-rt-name']
rTemplate.name = newRecordTemplateName
try:
session.commit()
flash('%s successfully edited!' % newRecordTemplateName)
except:
session.rollback()
raise
return redirect(url_for('addRecord',
catalog_id=catalog_id,
category_id=category_id))
else:
catalog = getCatalog(catalog_id)
category = getCategory(category_id)
return render_template('editRecordTemplate.html',
catalog=catalog,
category=category,
rTemplate=rTemplate)
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/add/template/<int:record_template_id>/delete/', methods=['GET', 'POST'])
@login_required
def deleteRecordTemplate(catalog_id, category_id, record_template_id):
catalog = getCatalog(catalog_id)
if catalog.user_id != login_session.get('user_id'):
flash('Only the owner of %s can delete this record template.'
% catalog.name, 'error')
return redirect(url_for('viewCatalogs'))
if request.method == 'POST':
delRecord_Template(record_template_id)
return redirect(url_for('addRecord',
catalog_id=catalog_id,
category_id=category_id))
else:
category = getCategory(category_id)
rTemplate = getRecordTemplate(record_template_id)
return render_template('deleteRecordTemplate.html',
catalog=catalog,
category=category,
rTemplate=rTemplate)
# JSON API Endpoints
@app.route('/catalog/json/')
def catalogListJSON():
catalogs = getCatalogs()
return jsonify(Catalogs=[c.serialize for c in catalogs])
@app.route('/catalog/<int:catalog_id>/category/json/')
def categoryListJSON(catalog_id):
categories = getCategories(catalog_id)
return jsonify(Categories=[c.serialize for c in categories])
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/json/')
def recordListJSON(catalog_id, category_id):
records = getRecordsByCategoryId(category_id)
return jsonify(Records=[r.serialize for r in records])
@app.route('/catalog/<int:catalog_id>/category/<int:category_id>/record/<int:record_id>/view/json/')
def fieldListJSON(catalog_id, category_id, record_id):
fields = getFields(record_id)
return jsonify(Fields=[r.serialize for r in fields])
# Helper functions for adding new entries or updating entries
def createUser(login_session):
newUser = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
try:
session.add(newUser)
session.commit()
except:
session.rollback()
raise
# user = session.query(User).filter_by(email=login_session['email']).one()
# return user.id
return newUser.id
def updateUser(user_id, picture, name):
user = session.query(User).filter_by(id=user_id).one()
change = False
if user.picture != picture:
user.picture = picture
change = True
if user.name != name:
user.name = name
change = True
if change is True:
try:
session.commit()
except:
session.rollback()
raise
def addNewRecord(category_id, record_template_id):
# The request object is a Werkzeug data structure called
# ImmutableMultiDict, which has a copy method that returns a
# mutable Wekzeug MultiDict.
formData = request.form.copy()
# Pop the first item (the record name) for a list on the dict, and remove
# the key from the dict.
recordName = formData.pop('record-name')
newRecordEntry = Record(name=recordName,
record_template_id=record_template_id,
category_id=category_id)
try:
session.add(newRecordEntry)
session.commit()
except:
session.rollback()
raise
# Call lists method on the formData multiDict, to get a list of
# tupples of keys and a list of all values corresponding to each
# unique key.
for keyValues in formData.lists():
fieldTemplateId = int(keyValues[0])
fieldValues = keyValues[1]
for fieldValue in fieldValues:
# After calling session.commit() on the newRecordEntry,
# SQLAlchemy automatically reloads the object from the database,
# allowing access to its assigned primary key.
newFieldEntry = Field(value=fieldValue,
field_template_id=fieldTemplateId,
record_id=newRecordEntry.id)
session.add(newFieldEntry)
try:
session.commit()
except:
session.rollback()
raise
# Helper functions to filter through and get database elements
def getUserID(email):
try:
user = session.query(User).filter_by(email=email).one()
return user.id
except:
return None
def getCatalogs():
return session.query(Catalog).all()
def getCatalog(catalog_id):
return session.query(Catalog).filter_by(id=catalog_id).one()
def getCategories(catalog_id):
return session.query(Category).filter_by(catalog_id=catalog_id).all()
def getCategory(category_id):
return session.query(Category).filter_by(id=category_id).one()
def getRecord(record_id):
return session.query(Record).filter_by(id=record_id).one()
def getRecordsByCategoryId(category_id):
return session.query(Record).filter_by(category_id=category_id).all()
def getRecordsByRecordTemplateId(record_template_id):
return session.query(Record).filter_by(
record_template_id=record_template_id).all()
def getFields(record_id):
return session.query(Field).filter_by(record_id=record_id).all()
def getRecordTemplate(record_template_id):
return session.query(RecordTemplate).filter_by(id=record_template_id).one()
def getRecordTemplates(category_id):
return session.query(RecordTemplate).filter_by(
category_id=category_id).all()
def getFieldTemplates(record_template_id):
return session.query(FieldTemplate).filter_by(
record_template_id=record_template_id).order_by(
asc(FieldTemplate.order))
def getOptions(field_template_id):
return session.query(Option).filter_by(
field_template_id=field_template_id).order_by(
asc(Option.id))
def getFormattedFields(record_id):
"""Returns field labels and values in the form of an array of
tupples of the field label and an array of the field values.
E.g. [ ( field label, [field value1, field value2] ) ]"""
record = getRecord(record_id)
fieldTemplates = getFieldTemplates(record.record_template_id)
fields = []
for fieldTemplate in fieldTemplates:
fieldLabel = fieldTemplate.label
valueList = session.query(Field).filter_by(
field_template_id=fieldTemplate.id,
record_id=record.id).order_by(
asc(Field.id))
fieldValues = []
for v in valueList:
fieldValues.append(v.value)
fields.append((fieldLabel, fieldValues))
return fields
def getFormattedFieldTemplatesWithOptions(record_template_id):
"""Returns a list of dictionaries containing
field template id, label, kind, and a list of options
for that field template."""
fieldTemplates = getFieldTemplates(record_template_id)
fieldsWithOptions = []
for fieldTemplate in fieldTemplates:
fieldTemplateDict = {
'id': fieldTemplate.id,
'label': fieldTemplate.label,
'kind': fieldTemplate.kind,
'options': []
}
options = getOptions(fieldTemplate.id)
for option in options:
fieldTemplateDict['options'].append((option.name, option.id))
fieldsWithOptions.append(fieldTemplateDict)
return fieldsWithOptions
def getFieldTemplatesWithValues(record_id):
"""Returns a list of dictionaries containing
field template id, label, kind, a list of options for
that field template, and the value(s) for that field.
Field Templates of the kind 'checkbox' may have more
than one of the options selected as s value"""
record = getRecord(record_id)
ftDictList = getFormattedFieldTemplatesWithOptions(
record.record_template_id)
for ftDict in ftDictList:
ftDict['values'] = []
ftId = ftDict['id']
fields = session.query(Field).filter_by(field_template_id=ftId).all()
for field in fields:
value = field.value
ftDict['values'].append(value)
return ftDictList
# Helper functions to delete database items
def delRecord(record_id):
record = getRecord(record_id)
fields = getFields(record_id)
for field in fields:
try:
session.delete(field)
session.commit()
except:
session.rollback()
raise
try:
session.delete(record)
session.commit()
except:
session.rollback()
raise
def delRecord_Template(record_template_id):
recordTemplate = getRecordTemplate(record_template_id)
fieldTemplates = getFieldTemplates(record_template_id)
records = getRecordsByRecordTemplateId(record_template_id)
flash('%s successfully deleted!' % recordTemplate.name)
for record in records:
delRecord(record.id)
for fieldTemplate in fieldTemplates:
options = getOptions(fieldTemplate.id)
for option in options:
try:
session.delete(option)
session.commit()
except:
session.rollback()
raise
try:
session.delete(fieldTemplate)
session.commit()
except:
session.rollback()
raise
try:
session.delete(recordTemplate)
session.commit()
except:
session.rollback()
raise
def delCategory(category_id):
category = getCategory(category_id)
recordTemplates = getRecordTemplates(category_id)
flash('%s successfully deleted!' % category.name)
for recordTemplate in recordTemplates:
delRecord_Template(recordTemplate.id)
try:
session.delete(category)
session.commit()
except:
session.rollback()
raise
def delCatalog(catalog_id):
catalog = getCatalog(catalog_id)
categories = getCategories(catalog_id)
flash('%s successfully deleted!' % catalog.name)
for category in categories:
delCategory(category.id)
try:
session.delete(catalog)
session.commit()
except:
session.rollback()
raise
if __name__ == '__main__':
app.secret_key = 'super_secret_key'
app.debug = True
app.run(host='0.0.0.0', port=5000)
| {
"repo_name": "gnodar01/catalog",
"path": "catalogizer.py",
"copies": "1",
"size": "36589",
"license": "mit",
"hash": -471585458241064700,
"line_mean": 34.6965853659,
"line_max": 144,
"alpha_frac": 0.6042799749,
"autogenerated": false,
"ratio": 4.166837490035303,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001520911170991458,
"num_lines": 1025
} |
from functools import wraps
from flask import Flask, render_template, request, Response
app = Flask(__name__)
from pymongo import MongoClient
from bson.objectid import ObjectId
import os
import json
import re
from utils.ara2man import ara2man
# SETTINGS
regexp = r'([\d同一二三四五六七八九十]+年[、同某\d一二三四五六七八九十零]*月[初間某\d卅廿一二三四五六七八九十零]+日?)'
keywords = [
{'text':'竊', 'prev': 30, 'color': 'light'},
{'text':'引用', 'prev': 0, 'color': 'important'}
]
uri = os.environ['MONGODB_URI']
client = MongoClient(uri,
connectTimeoutMS=30000,
socketTimeoutMS=None,
socketKeepAlive=True)
db = client.get_default_database()
judgements = db.judgements
users = db.users
def check_auth(username, password):
user = users.find_one({ 'username': username })
if user is None:
return False and False
else:
return username == user['username'] and password == user['password']
def authenticate():
"""Sends a 401 response that enables basic auth"""
return Response(
'Could not verify your access level for that URL.\n'
'You have to login with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="Login Required"'})
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
return authenticate()
return f(*args, **kwargs)
return decorated
@app.route('/')
@requires_auth
def index():
user = request.authorization.username
u = users.find({}, {'_id': 0, 'username': 1})[:]
finish = {}
finish.update(map(lambda e: (e['username'], judgements.find({'editor': e['username']}).count()), u))
pagination_len = 40
per_page = 80
page_num = int(request.args.get('p', 1))
query_conds = []
query_show = ''
show = request.args.get('show', 'false')
if show == 'false':
query_conds.append({'state': False})
query_show += ''
elif show == 'true':
query_conds.append({'state': True})
query_show += '&show=true'
else:
query_conds.append({})
query_show += '&show=both'
query_date = ''
year_ara = request.args.get('syr', '').strip()
month_ara = request.args.get('smth', '').strip()
day_ara = request.args.get('sd', '').strip()
if year_ara != '' and month_ara != '' and day_ara != '':
year_man = ara2man(year_ara)
month_man = ara2man(month_ara)
day_man = ara2man(day_ara)
query_date += '&syr={year}&smth={month}&sd={day}'.format(year=year_ara, month=month_ara, day=day_ara)
# Rules of date including abbreviations
search = [
re.compile('{year}年{month}月{day}日'.format(year=year_ara, month=month_ara, day=day_ara)),
re.compile('{year}年{month}月{day}日'.format(year=year_man, month=month_man, day=day_man)),
re.compile('{year}年.*同年{month}月{day}日'.format(year=year_ara, month=month_ara, day=day_ara)),
re.compile('{year}年.*同年{month}月{day}日'.format(year=year_man, month=month_man, day=day_man)),
re.compile('{year}年.*{month}月.*同月{day}日'.format(year=year_ara, month=month_ara, day=day_ara)),
re.compile('{year}年.*{month}月.*同月{day}日'.format(year=year_man, month=month_man, day=day_man)),
]
query_conds.append({'$or': [{'事實理由': {'$regex': reg}} for reg in search]})
query = judgements.find({'$and': query_conds})
part = query.skip((page_num - 1) * per_page).limit(per_page)
all_page_num = int(query.count() / per_page) + 1
if all_page_num < pagination_len:
lb = 1
ub = all_page_num
elif page_num < pagination_len:
lb = 1
ub = min(all_page_num, pagination_len)
elif page_num > all_page_num - pagination_len:
lb = all_page_num - pagination_len
ub = all_page_num
else:
lb = page_num - int(pagination_len / 2)
ub = page_num + int(pagination_len / 2)
return render_template('index.html',
judgements=list(part),
per_page=per_page,
current_page_num=page_num,
all_page_num=all_page_num,
search={'year': year_ara, 'month': month_ara, 'day': day_ara},
lb=lb,
ub=ub,
query_show=query_show,
query_date=query_date,
username=user,
finish=finish)
@app.route('/j/<jid>')
@requires_auth
def judgement(jid=None):
j = judgements.find_one({'_id': ObjectId(jid)})
raw = j['事實理由']
process = list(({'idx': idx, 'char': char, 'highlight': False, 'color': ''} for idx, char in enumerate(raw)))
# Search for highlight
for keyword in keywords:
highlights = re.finditer(re.compile(keyword['text']), raw)
for m in highlights:
start = max(m.start() - keyword['prev'], 0)
end = m.end()
for d in process[start:end]:
d['highlight'] = True
d['color'] = keyword['color']
split = re.split(regexp, raw)
content = []
count_of_date = 0
for text in split:
start = raw.index(text)
end = start + len(text)
if re.match(regexp, text) is not None:
count_of_date += 1
if text in j['dates']:
content.append({
'text': ''.join([p['char'] for p in process[start:end]]),
'chars': list(process[start:end]),
'is_date': True,
'select': True
})
else:
content.append({
'text': ''.join([p['char'] for p in process[start:end]]),
'chars': list(process[start:end]),
'is_date': True,
'select': False
})
else:
content.append({
'text': ''.join([p['char'] for p in process[start:end]]),
'chars': list(process[start:end]),
'is_date': False,
'select': False
})
count_of_identity = judgements.find({'identity': j['identity']}).count()
return render_template('judgement.html',
content=content,
judgement=j,
count_of_date=count_of_date,
count_of_identity=count_of_identity,
)
@app.route('/j/<jid>/save', methods=['POST'])
@requires_auth
def save(jid=None):
try:
user = request.authorization.username
j = judgements.find({'_id': ObjectId(jid)}).sort("_id").limit(1)
dates = request.form.getlist('chosen-date')
judgements.update_one({'_id': ObjectId(jid)},
{'$set': {'dates': dates, 'state': True, 'editor': user}},
upsert=False)
n = judgements.find({'_id': {'$gt': ObjectId(jid) },
'state': False}).sort('_id').limit(1)
if n.count() > 0:
return 'Successfully saved! Go to <a href="/j/{jid}">the next document</a>.'.format(jid=n[0]['_id'])
else:
return 'Successfully saved! Go back to <a href="/?show=both">the list</a>.'
except:
return 'Something went wrong. <a href="/j/{jid}">Go back</a> and try again.'.format(jid=jid)
@app.route('/j/<jid>/pass')
@requires_auth
def pass_over(jid=None):
try:
user = request.authorization.username
j = judgements.find_one({'_id': ObjectId(jid)})
judgements.update_one({'_id': ObjectId(jid)},
{'$set': {'dates': [], 'state': True, 'editor': user}},
upsert=False)
n = judgements.find({'_id': {'$gt': ObjectId(jid) },
'state': False}).sort('_id').limit(1)
if n.count() > 0:
return 'Successfully saved! Go to <a href="/j/{jid}">the next document</a>.'.format(jid=n[0]['_id'])
else:
return 'Successfully saved! Go back to <a href="/?show=both">the list</a>.'
except:
return 'Something went wrong. <a href="/j/{jid}">Go back</a> and try again.'.format(jid=jid)
@app.route('/j/<jid>/skip')
@requires_auth
def skip(jid=None):
try:
user = request.authorization.username
j = judgements.find_one({'_id': ObjectId(jid)})
judgements.update_one({'_id': ObjectId(jid)},
{'$set': {'tag': True, 'editor': user}},
upsert=False)
n = judgements.find({'_id': {'$gt': ObjectId(jid) },
'state': False}).sort('_id').limit(1)
if n.count() > 0:
return 'Temporarily skipped! Go to <a href="/j/{jid}">the next document</a>.'.format(jid=n[0]['_id'])
else:
return 'Temporarily skipped! Go back to <a href="/?show=both">the list</a>.'
except:
return 'Something went wrong. <a href="/j/{jid}">Go back</a> and try again.'.format(jid=jid)
if __name__ == "__main__":
app.run()
| {
"repo_name": "katrina376/wenizit",
"path": "application.py",
"copies": "1",
"size": "9448",
"license": "mit",
"hash": -4865900255987709000,
"line_mean": 36.4435483871,
"line_max": 113,
"alpha_frac": 0.5264914926,
"autogenerated": false,
"ratio": 3.498869630746044,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9490516036105019,
"avg_score": 0.006969017448204939,
"num_lines": 248
} |
from functools import wraps
from flask import Flask, request, Response
from flask import redirect, jsonify
from flask import g
from flask_jwt import verify_jwt
from flask.ext.jwt import current_user
from server import app, jwt, session
from server.models import *
# routing for basic page #
@app.route('/')
def basic_pages(**kwargs):
return app.send_static_file('index.html')
@app.errorhandler(404)
def page_not_found(e):
return jsonify(response="Invalid Request"), 404
class UserObj(object):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
@jwt.authentication_handler
def authenticate(username, password):
user = session.query(User).filter_by(username = username).first()
if user and user.verify_password(password):
return UserObj(id=user.id, username=user.username)
@jwt.user_handler
def load_user(payload):
user = session.query(User).filter_by(id = payload['user_id']).first()
if user:
return UserObj(id=user.id, username=user.username)
def protected(func):
@wraps(func)
def decorated_function(*args, **kwargs):
verify_jwt()
g.user = session.query(User).get(current_user.id)
return func(*args, **kwargs)
return decorated_function
#******* API v1 ********#
# user #
@app.route('/api/v1/user/', methods=['POST'])
def add_user():
# parse the json
json = request.get_json()
# extract data
username = json.get('username')
email = json.get('email')
password = json.get('password')
# sanity checks
if not username:
return jsonify(response="Could not create User, username is required"), 400
if not email:
return jsonify(response="Could not create User, email is required"), 400
if not password:
return jsonify(response="Could not create User, password is required"), 400
# create user and commit
new_user = User(username=username, email=email, password=password)
session.add(new_user)
session.commit()
# make sure db xact occured
if not new_user.id:
return jsonify(response="Could not create User"), 404
# Return user_id on success
return jsonify(user_id=new_user.id), 201
@app.route('/api/v1/user/', methods=['GET'])
@protected
def get_user():
# grab authenticated user
user = g.user
# return user params
return user.to_JSON(), 200
@app.route('/api/v1/user/', methods=['PUT'])
@protected
def update_user():
# grab authenticated user
user = g.user
# parse the json
json = request.get_json()
# update changed fields
if json.get('username'):
user.username = json.get('username')
if json.get('email'):
user.email = json.get('email')
if json.get('password'):
user.email = json.get('password')
# commit changes
session.commit()
# Return an auth token on success
token = user.generate_token()
return jsonify({ 'token': token.decode('ascii') }), 200
@app.route('/api/v1/user/', methods=['DELETE'])
@protected
def delete_user():
# grab authenticated user
user = g.user
# delete user from db
session.delete(user)
# commit changes
session.commit()
# return
return jsonify(response="User deleted."), 200
# constellations #
@app.route('/api/v1/constellations/', methods=['POST'])
@protected
def add_constellation():
# grab authenticated user
user = g.user
# parse the json
json = request.get_json()
# extract data
name = json.get('name')
vectors = json.get('vectors')
# sanity checks
if not name:
return jsonify(response="Could not create Constellation, name is required"), 400
if not vectors:
return jsonify(response="Could not create Constellations, one or more vectors are required"), 400
# create new constellation for authenticated user
new_constellation = Constellation(user_id=user.id, name=name)
session.add(new_constellation)
session.commit()
# create vectors for constellation
for vector in vectors:
new_vector = Vector(constellation_id=new_constellation.id, a=vector[0], b=vector[1])
session.add(new_vector)
session.commit()
# return constellation id
return jsonify(constellation_id=new_constellation.id), 201
@app.route('/api/v1/constellations/', methods=['GET'])
@protected
def get_constellations():
# grab authenticated user
user = g.user
# look up all the constellations associated with the user
constellations = session.query(Constellation).filter_by(user_id=user.id).all()
# sanity check
if not constellations:
return jsonify(response="No constellations found for user: {}".format(user.id)), 404
# compose each constellation
return_list = []
for constellation in constellations:
vectors = session.query(Vector).filter_by(constellation_id=constellation.id).all()
return_list.append({"info":constellation.to_obj(), "vectors":[vector.to_array() for vector in vectors]})
# return
return jsonify(constellations=return_list), 200
@app.route('/api/v1/constellations/<int:constellation_id>', methods=['GET'])
@protected
def get_constellation(constellation_id):
# grab authenticated user
user = g.user
# get the constellation
constellation = session.query(Constellation).get(constellation_id)
# sanity check
if not constellation:
return jsonify(response="Constellation {} not found for user: ".format(constellation_id, user.id)), 404
# grab vectors for constellation
vectors = session.query(Vector).filter_by(constellation_id=constellation_id).all()
# compose response and return
return jsonify(info=constellation.to_obj(), vectors=[vector.to_array() for vector in vectors]), 200
@app.route('/api/v1/constellations/<int:constellation_id>', methods=['PUT'])
@protected
def update_constellation(constellation_id):
# grab authenticated user
user = g.user
# get the constellation
constellation = session.query(Constellation)\
.filter((Constellation.id==constellation_id) & (Constellation.user_id==user.id))\
.first()
if not constellation:
return jsonify(response="Constellation not found for authenticated user."), 404
# parse the json
json = request.get_json()
# extract constellation data
name = json.get('name')
vectors = json.get('vectors')
# update the constellation information
if name:
constellation.name = name
session.commit()
# if we got new vectors
if vectors:
# delete all vectors associated with the constellation
session.query(Vector)
# associate new vectors with constellation
for vector in vectors:
new_vector = Vector(constellation_id=constellation.id, a=vector[0], b=vector[1])
session.add(new_vector)
session.commit()
return jsonify(response="Constellation Added"), 200
@app.route('/api/v1/constellations/star/<int:star_id>', methods=['GET'])
@protected
def get_constellations_with_star(star_id):
# grab authenticated user
user = g.user
# grab all constellation ids with given star_id
constellation_ids = session.query(Vector.constellation_id).filter((Vector.a == star_id) | (Vector.b == star_id)).all()
if not constellation_ids:
return jsonify(response="That star is not in any constellations for this user."), 404
# reformat to something that doesn't suck
constellation_ids = [constellation_id[0] for constellation_id in constellation_ids]
# grab constellations from ids
constellations = session.query(Constellation).filter(Constellation.id.in_(constellation_ids))
# grab all vectors for each constellation
constellation_data = []
for constellation in constellations:
# grab vectors for constellation
vectors = session.query(Vector).filter_by(constellation_id=constellation.id).all()
# compile into response array
constellation_data.append({
'info':constellation.to_obj(),
'vectors':[vector.to_array() for vector in vectors]
})
# return compiled constellation data
return jsonify(constellations=constellation_data), 200
@app.route('/api/v1/constellations/<int:constellation_id>', methods=['DELETE'])
@protected
def delete_constellation(constellation_id):
# grab authenticated user
user = g.user
# get the constellation
constellation = session.query(Constellation).get(constellation_id)
# sanity check
if not constellation:
return jsonify(response="Constellation {} not found for user: ".format(constellation_id, user.id)), 404
# delete constellation from db
session.delete(constellation)
# commit changes
session.commit()
# return
return jsonify(response="Constellation deleted."), 200
| {
"repo_name": "meggers/constellate-server",
"path": "server/controllers.py",
"copies": "1",
"size": "8917",
"license": "mit",
"hash": -2896941065076943400,
"line_mean": 28.7233333333,
"line_max": 122,
"alpha_frac": 0.675787821,
"autogenerated": false,
"ratio": 3.768808114961961,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9904954169353233,
"avg_score": 0.007928353321745598,
"num_lines": 300
} |
from functools import wraps
from flask import Flask, session, redirect, url_for, render_template, request, flash
from flask.ext.sqlalchemy import SQLAlchemy
import bcrypt
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///auth.db'
db = SQLAlchemy(app)
app.secret_key = "This is supposed to be a secret"
class User(db.Model):
"""
User database model
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
password = db.Column(db.String(256))
def __init__(self, username, password):
self.username = username
self.password = self.hash(password)
@staticmethod
def hash(password):
return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
def verify(self, password):
if bcrypt.hashpw(password.encode('utf-8'), self.password.encode('utf-8')) == self.password:
return True
return False
def __repr__(self):
return '<User %r>' % self.username
def authenticated(f):
"""
Decorator to enforce authentication on routed methods
"""
@wraps(f)
def wrapper(*args, **kwargs):
if 'username' in session:
return f(*args, **kwargs)
else:
flash('You must be logged in')
return redirect(url_for('index'))
return wrapper
@app.route('/')
def index():
return render_template('index.html')
@app.route('/register', methods=['GET','POST'])
def register():
"""
Checks database to verify user doesn't exist,
then creates and logs on new user
Any error is flashed
"""
if request.method == 'POST':
result = User.query.filter_by(username=request.form['username']).first()
if result is None:
new_user = User(request.form['username'],request.form['password'])
session['username'] = new_user.username
db.session.add(new_user)
db.session.commit()
flash('registered and logged in')
else:
flash('user already exists')
return redirect(url_for('index'))
@app.route('/login', methods=['GET','POST'])
def login():
"""
Verifies user exists and compares password
Any error is flashed
"""
if request.method == 'POST':
result = User.query.filter_by(username=request.form['username']).first()
if result and result.verify(request.form['password']):
session['username'] = result.username
else:
flash('wrong user or password')
return redirect(url_for('index'))
@app.route('/logout')
def logout():
"""
Destroys any active session
"""
session.pop('username', None)
flash('Logged out')
return redirect(url_for('index'))
@app.route('/secret')
@authenticated
def secret():
"""
Authenticated only route
@authenticated will flash a message if not authed
"""
return render_template('secret.html')
if __name__ == "__main__":
app.run(debug=True, host='0.0.0.0')
| {
"repo_name": "kryptn/FlaskBareAuth",
"path": "app.py",
"copies": "1",
"size": "3035",
"license": "mit",
"hash": -720827180377481000,
"line_mean": 24.7203389831,
"line_max": 99,
"alpha_frac": 0.6131795717,
"autogenerated": false,
"ratio": 3.936446173800259,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5049625745500259,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import g
from app.constants import (
ask_to_register_answer, student_required_answer, educator_required_answer
)
from app.models import User
from tg_bot import bot
def login_required_message(func):
@wraps(func)
def wrapper(message):
user = User.query.filter_by(tg_id=message.chat.id).first()
if user:
g.current_tbot_user = user
func(message)
else:
bot.reply_to(message, ask_to_register_answer)
return wrapper
def login_required_callback(func):
@wraps(func)
def wrapper(call_back):
user = User.query.filter_by(tg_id=call_back.message.chat.id).first()
if user:
g.current_tbot_user = user
func(call_back)
else:
bot.edit_message_text(
text=ask_to_register_answer,
chat_id=call_back.message.chat.id,
message_id=call_back.message.message_id,
parse_mode="HTML"
)
return wrapper
def login_required_inline(func):
@wraps(func)
def wrapper(inline_query):
user = User.query.filter_by(tg_id=inline_query.from_user.id).first()
if user:
g.current_tbot_user = user
func(inline_query)
else:
bot.answer_inline_query(
inline_query_id=inline_query.id,
results=[],
switch_pm_text=ask_to_register_answer,
switch_pm_parameter="new_from_inline",
cache_time=1,
is_personal=True
)
return wrapper
def student_required_message(func):
@wraps(func)
def wrapper(message):
if not g.current_tbot_user.is_educator:
func(message)
else:
bot.reply_to(message, student_required_answer)
return wrapper
def student_required_callback(func):
@wraps(func)
def wrapper(call_back):
if not g.current_tbot_user.is_educator:
func(call_back)
else:
bot.edit_message_text(
text=student_required_answer,
chat_id=g.current_tbot_user.tg_id,
message_id=call_back.message.message_id,
parse_mode="HTML"
)
return wrapper
def student_required_inline(func):
@wraps(func)
def wrapper(inline_query):
if not g.current_tbot_user.is_educator:
func(inline_query)
else:
bot.answer_inline_query(
inline_query_id=inline_query.id,
results=[],
switch_pm_text=student_required_answer,
switch_pm_parameter="educator_from_inline",
cache_time=10,
is_personal=True
)
return wrapper
def educator_required_message(func):
@wraps(func)
def wrapper(message):
if g.current_tbot_user.is_educator:
func(message)
else:
bot.reply_to(message, educator_required_answer)
return wrapper
def educator_required_callback(func):
@wraps(func)
def wrapper(call_back):
if g.current_tbot_user.is_educator:
func(call_back)
else:
bot.edit_message_text(
text=educator_required_answer,
chat_id=g.current_tbot_user.tg_id,
message_id=call_back.message.message_id,
parse_mode="HTML"
)
return wrapper
def educator_required_inline(func):
@wraps(func)
def wrapper(inline_query):
if g.current_tbot_user.is_educator:
func(inline_query)
else:
bot.answer_inline_query(
inline_query_id=inline_query.id,
results=[],
switch_pm_text=educator_required_answer,
switch_pm_parameter="student_from_inline",
cache_time=10,
is_personal=True
)
return wrapper
from telebot_login import help_decorators
| {
"repo_name": "EeOneDown/spbu4u",
"path": "telebot_login/__init__.py",
"copies": "1",
"size": "4022",
"license": "apache-2.0",
"hash": -7583553841568528000,
"line_mean": 26.9305555556,
"line_max": 77,
"alpha_frac": 0.5626553953,
"autogenerated": false,
"ratio": 3.7765258215962443,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9838354497319525,
"avg_score": 0.00016534391534391533,
"num_lines": 144
} |
from functools import wraps
from flask import g, request
from flask.ext.restful import abort
from app.auth.models import User
def login_required(f):
@wraps(f)
def decorated_function(*args, **kwargs):
auth_header = request.headers.get('Authorization', 'Token Null')
token = [item.encode('ascii') for item in auth_header.split(' ')]
if len(token) == 2 and token[0] == 'Token':
user = User.verify_auth_token(token[1])
if user:
g.user = user
return f(*args, **kwargs)
abort(401, message='Invalid Token - Authorization Required')
return decorated_function
def has_permissions(perms=[]):
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
user = g.user
for p in perms:
if not user.has_permission(p):
abort(401, message='Operation not permitted')
return f(*args, **kwargs)
return decorated_function
return decorator
| {
"repo_name": "bmbove/flask-api-boilerplate",
"path": "app/base/decorators.py",
"copies": "1",
"size": "1039",
"license": "mit",
"hash": -8979283358412634000,
"line_mean": 30.4848484848,
"line_max": 73,
"alpha_frac": 0.5890279115,
"autogenerated": false,
"ratio": 4.156,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.52450279115,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import jsonify, request, g, abort
import rethinkdb as r
from app import app
from models.Error import Error
def login_required(function_to_wrap):
@wraps(function_to_wrap)
def wrap(*args, **kwargs):
try:
if request.method == 'GET':
data = r.table("user_token").filter(
{"user_id": request.args.get('user_id'), "auth_token": request.args.get('auth_token')}).run(
g.rdb_conn)
else:
data = r.table("user_token").filter(
{"user_id": request.json.get('user_id'), "auth_token": request.json.get('auth_token')}).run(
g.rdb_conn)
if data.next():
print("cool you are authorized man!")
return function_to_wrap(*args, **kwargs)
else:
abort(400)
except Exception as e:
abort(403)
return wrap
@app.route("/page/", methods=['GET'])
@login_required
def get_next_page():
data = r.table('page').filter({'completed': False}).run(g.rdb_conn)
try:
result_json = data.next()
return jsonify({"restaurant_id": result_json['restaurant_id'], "page_id": result_json['id'],
"page_url": result_json['url']})
except Exception as e:
print(e)
return jsonify({"status": "No urls left"})
@app.route("/menu/", methods=['POST'])
@login_required
def create_menu():
if ('restaurant_id' and 'type' and 'user_id' and 'page_id' and 'description') in request.json:
data = request.get_json()
try:
page_data = r.table('page').get(data['page_id']).run(g.rdb_conn)
data['page_url'] = page_data['url']
except Exception as e:
print(e)
return Error(code=8, message='invalid_page_id').to_json()
try:
restaurant_data = r.table('restaurant').get(data['restaurant_id']).run(g.rdb_conn)
data['restaurant_name'] = restaurant_data['name']
data['restaurant_address'] = restaurant_data['address']
data['restaurant_zip'] = restaurant_data['zip']
except Exception as e:
print(e)
return Error(code=9, message='invalid_restaurant_id').to_json()
menu = r.table('menu').insert(data).run(g.rdb_conn)
if menu['inserted'] == 1:
return jsonify({"status": "okay", "restaurant_id": data['restaurant_id'], "page_id": data['page_id'],
"menu_id": menu['generated_keys'][0]})
else:
abort(400)
else:
return Error(code=10, message='missing_parameters').to_json()
@app.route("/menu/category/", methods=['POST'])
@login_required
def create_category():
if ('menu_id' and 'name' and 'user_id' and 'description') in request.json:
data = request.get_json()
try:
menu_data = r.table('menu').get(data['menu_id']).run(g.rdb_conn)
data['restaurant_id'] = menu_data['restaurant_id']
data['restaurant_name'] = menu_data['restaurant_name']
data['restaurant_address'] = menu_data['restaurant_address']
data['restaurant_zip'] = menu_data['restaurant_zip']
data['page_id'] = menu_data['page_id']
data['page_url'] = menu_data['page_url']
data['menu_type'] = menu_data['type']
data['menu_description'] = menu_data['description']
except Exception as e:
print(e)
return Error(code=11, message='invalid_menu_id').to_json()
menu_category = r.table('menu_category').insert(data).run(g.rdb_conn)
if menu_category['inserted'] == 1:
return jsonify({"status": "okay", "restaurant_id": data['restaurant_id'], "page_id": data['page_id'],
"menu_id": data['menu_id'], "menu_category_id": menu_category['generated_keys'][0]})
else:
abort(400)
else:
return Error(code=10, message='missing_parameters').to_json()
@app.route("/menu/item/", methods=['POST'])
@login_required
def create_item():
if ('menu_category_id' and 'name' and 'user_id' and 'description' and 'price' and 'extras') in request.json:
data = request.get_json()
try:
menu_category_data = r.table('menu_category').get(data['menu_category_id']).run(g.rdb_conn)
data['restaurant_id'] = menu_category_data['restaurant_id']
data['restaurant_name'] = menu_category_data['restaurant_name']
data['restaurant_address'] = menu_category_data['restaurant_address']
data['restaurant_zip'] = menu_category_data['restaurant_zip']
data['page_id'] = menu_category_data['page_id']
data['page_url'] = menu_category_data['page_url']
data['menu_id'] = menu_category_data['menu_id']
data['menu_type'] = menu_category_data['menu_type']
data['menu_description'] = menu_category_data['menu_description']
data['menu_category_id'] = menu_category_data['id']
data['menu_category_name'] = menu_category_data['name']
data['menu_category_description'] = menu_category_data['description']
except Exception as e:
print(e)
return Error(code=12, message='invalid_menu_category_id').to_json()
menu_item = r.table('menu_item').insert(data).run(g.rdb_conn)
if menu_item['inserted'] == 1:
return jsonify({"status": "okay", "restaurant_id": data['restaurant_id'], "page_id": data['page_id'],
"menu_id": data['menu_id'], "menu_category_id": data['menu_category_id'],
"menu_item_id": menu_item['generated_keys'][0]})
else:
abort(400)
else:
return Error(code=10, message='missing_parameters').to_json()
def load():
pass
| {
"repo_name": "suparngp/letswikit",
"path": "ui/controllers/menu.py",
"copies": "1",
"size": "5941",
"license": "apache-2.0",
"hash": -1478312903554988800,
"line_mean": 38.8724832215,
"line_max": 113,
"alpha_frac": 0.561858273,
"autogenerated": false,
"ratio": 3.703865336658354,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4765723609658354,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import json
from config import atom_feeds
def multiline_to_list(data, whitespace_separator=True, unique_only=True, filter_empty=True):
if not data:
return []
if whitespace_separator:
data = data.replace(' ', '\n')
data_list = data.replace('\r', '').split('\n')
if unique_only:
data_list = list_uniquify(data_list)
if filter_empty:
data_list = list(filter(lambda e: len(e) > 0, data_list))
return data_list
def list_uniquify(data):
used = set()
return [e for e in data if e not in used and (used.add(e) or True)]
def cmp_to_key(cmp_func, getter=None):
class K(object):
def __init__(self, obj, *args):
self.obj = obj
def extract(self, obj):
if getter:
return getter(obj)
return obj
def __lt__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) < 0
def __gt__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) > 0
def __eq__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) == 0
def __le__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) <= 0
def __ge__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) >= 0
def __ne__(self, other):
return cmp_func(self.extract(self.obj), self.extract(other.obj)) != 0
return K
def chunks(l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
def json_response(func):
@wraps(func)
def wrapped(*args, **kwargs):
response = func(*args, **kwargs)
code = 200
if isinstance(response, tuple):
response, code = response
dump = json.dumps(response, indent=2, sort_keys=False)
return dump, code, {'Content-Type': 'application/json; charset=utf-8'}
return wrapped
def atom_feed(title):
def decorator(func):
atom_feeds.append({'func': 'tracker.{}'.format(func.__name__), 'title': title})
@wraps(func)
def wrapped(*args, **kwargs):
return func(*args, **kwargs)
return wrapped
return decorator
def issue_to_numeric(issue_label):
self_parts = issue_label.split('-')
return int(self_parts[1] + self_parts[2].rjust(7, '0'))
| {
"repo_name": "anthraxx/arch-security-tracker",
"path": "tracker/util.py",
"copies": "2",
"size": "2496",
"license": "mit",
"hash": -5436432959109468000,
"line_mean": 27.6896551724,
"line_max": 92,
"alpha_frac": 0.5821314103,
"autogenerated": false,
"ratio": 3.5404255319148934,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5122556942214893,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import make_response
from flask import Flask
from flask import request, Response
from OpenSSL import SSL
app = Flask(__name__)
users = {'admin': 'secret', 'user': 'user'}
@app.before_request
def before_request():
print request.headers
def check_auth(username, password):
"""This function is called to check if a username /
password combination is valid.
"""
passwd = users[username]
return passwd == password
#return username == 'admin' and password == 'secret'
def authenticate():
"""Sends a 401 response that enables basic auth"""
return Response(
'Could not verify your access level for that URL.\n'
'You have to login with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="Login Required"'})
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
return authenticate()
return f(*args, **kwargs)
return decorated
@app.route("/")
def hello():
return "Hello World!"
@app.route("/api/secure")
@requires_auth
def secure():
return "Secured resource"
@app.route("/api/admin")
@requires_auth
def admin():
if request.authorization and request.authorization.username == 'admin':
response = make_response("Secured resource", 200)
response.cache_control.private = True
return response
else:
return make_response("Verboten!", 403)
@app.route("/api/same")
def same():
return "I always return hello world!"
@app.route("/api/user")
def user():
if request.authorization and request.authorization.username:
response = make_response(request.authorization.username, 200)
response.cache_control.private = True
return response
else:
return "No user"
if __name__ == "__main__":
context = SSL.Context(SSL.SSLv23_METHOD)
context.use_privatekey_file('/etc/ssl/localhost/server.key')
context.use_certificate_file('/etc/ssl/localhost/server.cert')
app.run("127.0.0.1", 8080, debug=True, ssl_context=context)
| {
"repo_name": "srmelody/cachetools",
"path": "traffic.py",
"copies": "1",
"size": "2177",
"license": "apache-2.0",
"hash": 2623375436654067000,
"line_mean": 22.9230769231,
"line_max": 75,
"alpha_frac": 0.6628387689,
"autogenerated": false,
"ratio": 3.9509981851179674,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.011181800655484866,
"num_lines": 91
} |
from functools import wraps
from flask import make_response, render_template, request
from flask_login import current_user
from .utils import patch_http_cache_headers
def templated(template=None):
"""
Taken from http://flask.pocoo.org/docs/0.10/patterns/viewdecorators/
"""
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
template_name = template
if template_name is None:
template_name = request.endpoint.replace(".", "/") + ".html"
ctx = f(*args, **kwargs)
if ctx is None:
ctx = {}
elif not isinstance(ctx, dict):
return ctx
return render_template(template_name, **ctx)
return decorated_function
return decorator
def http_cache(timeout=None):
"""
Add Flask cache response headers based on timeout in seconds.
If timeout is None, caching will be disabled.
Otherwise, caching headers are set to expire in now + timeout seconds
Example usage:
@app.route('/map')
@http_cache(timeout=60)
def index():
return render_template('index.html')
Originally from https://gist.github.com/glenrobertson/954da3acec84606885f5
"""
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
response = make_response(f(*args, **kwargs))
if current_user.is_authenticated:
return response
else:
return patch_http_cache_headers(response, timeout)
return decorated_function
return decorator
| {
"repo_name": "jazzband/website",
"path": "jazzband/decorators.py",
"copies": "2",
"size": "1625",
"license": "mit",
"hash": 3002294419196657700,
"line_mean": 26.0833333333,
"line_max": 78,
"alpha_frac": 0.6116923077,
"autogenerated": false,
"ratio": 4.310344827586207,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 60
} |
from functools import wraps
from flask import (
Blueprint,
render_template,
request,
session,
flash,
abort,
redirect,
)
from PyPaste.utils import pypaste_url_for as url_for
from PyPaste.forms import LoginForm, LogoutForm, DeletePasteForm
from PyPaste.models.users import User
from PyPaste.models.pastes import Paste
admin = Blueprint(
'admin',
__name__,
url_prefix='/a',
template_folder='templates'
)
def login_required(func):
"""
Decorator that ensures a user
is logged in before accessing
a view, else throws up a 401
"""
@wraps(func)
def wrapper(*a, **kw):
if not session.get('logged_in'):
abort(401)
return func(*a, **kw)
return wrapper
@admin.route('/in', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
username = form.username.data
password = form.password.data
if User.password_match(username, password):
session['username'] = username
session['logged_in'] = True
return redirect(url_for('pastes.index'))
else:
flash('Incorrect username/password', 'error')
return render_template('login.html', form=form)
@admin.route('/out', methods=['GET', 'POST'])
@login_required
def logout():
form = LogoutForm()
if request.method == 'POST' and form.validate_on_submit():
if session.get('username') == form.username.data:
session.pop('username')
session.pop('logged_in')
session.modified = True
return redirect(url_for('pastes.index'))
return render_template('logout.html', form=form)
@admin.route('/del/<hash>', methods=['GET', 'POST'])
@login_required
def delete_paste(hash):
form = DeletePasteForm()
if form.validate_on_submit():
if not Paste.delete(form.paste_hash.data):
flash('Deletion failed', 'error')
return redirect(request.url)
return redirect(url_for('pastes.recent'))
return render_template('delete.html', form=form, hash=hash)
| {
"repo_name": "joealcorn/PyPaste",
"path": "PyPaste/views/admin/__init__.py",
"copies": "1",
"size": "2108",
"license": "mit",
"hash": -1523774362370896100,
"line_mean": 24.7073170732,
"line_max": 64,
"alpha_frac": 0.6228652751,
"autogenerated": false,
"ratio": 3.79136690647482,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.991423218157482,
"avg_score": 0,
"num_lines": 82
} |
from functools import wraps
from flask import redirect, request, session, url_for
from app.models.user import User
from app.utils.time import is_less_than_days_ago
def redirect_to_sign_in(f):
@wraps(f)
def wrapped(*args, **kwargs):
if 'user_details' not in session:
return redirect(url_for('main.sign_in'))
else:
return f(*args, **kwargs)
return wrapped
def log_in_user(user_id):
try:
user = User.from_id(user_id)
# the user will have a new current_session_id set by the API - store it in the cookie for future requests
session['current_session_id'] = user.current_session_id
# Check if coming from new password page
if 'password' in session.get('user_details', {}):
user.update_password(session['user_details']['password'], validated_email_access=True)
user.activate()
user.login()
finally:
# get rid of anything in the session that we don't expect to have been set during register/sign in flow
session.pop("user_details", None)
session.pop("file_uploads", None)
return redirect_when_logged_in(platform_admin=user.platform_admin)
def redirect_when_logged_in(platform_admin):
next_url = request.args.get('next')
if next_url and _is_safe_redirect_url(next_url):
return redirect(next_url)
return redirect(url_for('main.show_accounts_or_dashboard'))
def email_needs_revalidating(user):
return not is_less_than_days_ago(user.email_access_validated_at, 90)
# see http://flask.pocoo.org/snippets/62/
def _is_safe_redirect_url(target):
from urllib.parse import urljoin, urlparse
host_url = urlparse(request.host_url)
redirect_url = urlparse(urljoin(request.host_url, target))
return redirect_url.scheme in ('http', 'https') and \
host_url.netloc == redirect_url.netloc
| {
"repo_name": "alphagov/notifications-admin",
"path": "app/utils/login.py",
"copies": "1",
"size": "1880",
"license": "mit",
"hash": -7922210204723726000,
"line_mean": 33.1818181818,
"line_max": 113,
"alpha_frac": 0.6718085106,
"autogenerated": false,
"ratio": 3.6084452975047983,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9777726397981694,
"avg_score": 0.0005054820246207806,
"num_lines": 55
} |
from functools import wraps
from flask import render_template, flash, request, redirect, url_for, session
from passlib.hash import sha256_crypt
from config import app, db
from forms import RegisterForm, VideoForm, CommentForm
from models import Users, Videos, Comments
from werkzeug.contrib.fixers import ProxyFix
app = app
db.init_app(app)
db.create_all()
# TODO: Decorator login required
def login_required(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if session['logged_in'] == False:
return redirect(url_for('login', next=request.url))
return f(*args, **kwargs)
return decorated_function
# TODO: HomePage
@app.route('/')
def index():
data = Videos.query.all()
if len(data) > 0:
return render_template('home.html', videos=data)
else:
msg = 'No Videos Found'
return render_template('home.html', msg=msg)
# TODO: About
@app.route('/about')
def about():
return render_template('about.html')
# TODO: Register
@app.route('/register', methods=['GET', 'POST'])
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
name = form.name.data
username = form.username.data
email = form.email.data
password = sha256_crypt.encrypt(str(form.password.data))
user = Users(name=name, username=username, email=email, password=password)
try:
db.session.add(user)
db.session.commit()
except:
flash("Something went wrong with DB")
flash('You are now registered and can login!', 'success')
return redirect(url_for('login'))
return render_template('register.html', form=form)
# TODO: Login
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
username = request.form['username']
password_candidate = request.form['password']
result = Users.query.filter_by(username=username).first()
if result is not None:
password = result.password
if sha256_crypt.verify(password_candidate, password):
session['logged_in'] = True
session['username'] = username
flash('You are now logged in', 'success')
return redirect(url_for('dashboard'))
else:
error = 'Invalid login'
return render_template('login_html', error=error)
else:
error = 'Username not found'
return render_template('login.html', error=error)
return render_template('login.html')
# TODO: Logout
@app.route('/logout')
@login_required
def logout():
session.clear()
flash('You are now logged out', 'success')
return redirect(url_for('login'))
# TODO: Videos
@app.route('/videos')
def videos():
data = Videos.query.all()
if len(data) > 0:
return render_template('videos.html', videos=data)
else:
msg = 'No Videos Found'
return render_template('videos.html', msg=msg)
# TODO: Video Details
@app.route('/video/<int:id>/', methods=['GET', 'POST'])
def video(id):
data = Videos.query.get(id)
form = CommentForm(request.form)
if request.method == 'POST' and form.validate():
user = Users.query.filter_by(username=data.author).first()
comment_candidate = form.comment.data
comment = Comments(body=comment_candidate, video_id=data.id, user_id=user.id)
db.session.add(comment)
db.session.commit()
msg = "Comment added!"
return render_template('video.html', video=data, form=form, msg=msg)
if data:
return render_template('video.html', video=data, form=form)
else:
msg = "No video found!"
return render_template('video.html', msg=msg)
# TODO: Add Video
@app.route('/add_video', methods=["GET", "POST"])
@login_required
def add_video():
form = VideoForm(request.form)
if request.method == "POST" and form.validate():
title = form.title.data
link = form.link.data
author = session['username']
video = Videos(title, link, author)
db.session.add(video)
db.session.commit()
flash("Video created", "success")
return redirect(url_for('dashboard'))
else:
error = form.errors
return render_template('add_video.html', form=form, error=error)
return render_template('add_video.html', form=form)
# TODO: Dashboard
@app.route('/dashboard')
@login_required
def dashboard():
data = Videos.query.all()
if len(data) > 0:
return render_template('dashboard.html', videos=data)
else:
msg = 'No Videos Found'
return render_template('dashboard.html', msg=msg)
# TODO: Edit Video
@app.route('/edit_video/<int:id>/', methods=['GET', 'POST'])
@login_required
def edit_video(id):
data = Videos.query.get(id)
form = VideoForm(request.form)
form.title.data = data.title
form.link.data = data.link
if request.method == 'POST' and form.validate():
data.title = request.form["title"]
data.link = request.form["link"]
db.session.commit()
flash("Video updated!", "success")
return redirect(url_for('dashboard'))
return render_template('edit_video.html', form=form)
# TODO: Delete Video
@app.route('/delete_video/<int:id>', methods=['GET', 'POST'])
@login_required
def delete_video(id):
data = Videos.query.get(id)
if data:
db.session.delete(data)
db.session.commit()
msg = "Video deleted!"
return render_template('dashboard.html', msg=msg)
else:
error = "Video was not deleted!"
return render_template('dashboard.html', error=error)
app.wsgi_app = ProxyFix(app.wsgi_app)
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
| {
"repo_name": "alaturqua/my_flask_app",
"path": "app.py",
"copies": "1",
"size": "5848",
"license": "apache-2.0",
"hash": -6992586259058810000,
"line_mean": 28.9897435897,
"line_max": 85,
"alpha_frac": 0.6241450068,
"autogenerated": false,
"ratio": 3.657285803627267,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9777935902400829,
"avg_score": 0.0006989816052873669,
"num_lines": 195
} |
from functools import wraps
from flask import request, Blueprint, render_template, jsonify, flash, \
redirect, url_for
from sqlalchemy.orm.util import join
from my_app import db, app
from my_app.catalog.models import Product, Category
catalog = Blueprint('catalog', __name__)
def template_or_json(template=None):
""""Return a dict from your view and this will either
pass it to a template or render json. Use like:
@template_or_json('template.html')
"""
def decorated(f):
@wraps(f)
def decorated_fn(*args, **kwargs):
ctx = f(*args, **kwargs)
if request.is_xhr or not template:
return jsonify(ctx)
else:
return render_template(template, **ctx)
return decorated_fn
return decorated
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
@catalog.route('/')
@catalog.route('/home')
@template_or_json('home.html')
def home():
products = Product.query.all()
return {'count': len(products)}
@catalog.route('/product/<id>')
def product(id):
product = Product.query.get_or_404(id)
return render_template('product.html', product=product)
@catalog.route('/products')
@catalog.route('/products/<int:page>')
def products(page=1):
products = Product.query.paginate(page, 10)
return render_template('products.html', products=products)
@catalog.route('/product-create', methods=['GET', 'POST'])
def create_product():
if request.method == 'POST':
name = request.form.get('name')
price = request.form.get('price')
categ_name = request.form.get('category')
category = Category.query.filter_by(name=categ_name).first()
if not category:
category = Category(categ_name)
product = Product(name, price, category)
db.session.add(product)
db.session.commit()
flash('The product %s has been created' % name, 'success')
return redirect(url_for('catalog.product', id=product.id))
return render_template('product-create.html')
@catalog.route('/product-search')
@catalog.route('/product-search/<int:page>')
def product_search(page=1):
name = request.args.get('name')
price = request.args.get('price')
company = request.args.get('company')
category = request.args.get('category')
products = Product.query
if name:
products = products.filter(Product.name.like('%' + name + '%'))
if price:
products = products.filter(Product.price == price)
if company:
products = products.filter(Product.company.like('%' + company + '%'))
if category:
products = products.select_from(join(Product, Category)).filter(
Category.name.like('%' + category + '%')
)
return render_template(
'products.html', products=products.paginate(page, 10)
)
@catalog.route('/category-create', methods=['POST', ])
def create_category():
name = request.form.get('name')
category = Category(name)
db.session.add(category)
db.session.commit()
return render_template('category.html', category=category)
@catalog.route('/category/<id>')
def category(id):
category = Category.query.get_or_404(id)
return render_template('category.html', category=category)
@catalog.route('/categories')
def categories():
categories = Category.query.all()
return render_template('categories.html', categories=categories)
| {
"repo_name": "abacuspix/NFV_project",
"path": "Flask_Framework_Cookbook/Chapter-4-master/my_app/catalog/views.py",
"copies": "1",
"size": "3475",
"license": "mit",
"hash": -548645942632864800,
"line_mean": 28.4491525424,
"line_max": 77,
"alpha_frac": 0.6509352518,
"autogenerated": false,
"ratio": 3.7895310796074155,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9940466331407416,
"avg_score": 0,
"num_lines": 118
} |
from functools import wraps
from flask import request, g
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from itsdangerous import SignatureExpired, BadSignature
from app import app
from app.utils.errors import UNAUTHORIZED, FORBIDDEN
TWO_WEEKS = 1209600
def generate_token(user, expiration=TWO_WEEKS):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({
'id': user.id,
'email': user.email,
'is_admin': user.is_admin
})
def verify_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except (SignatureExpired, BadSignature):
return None
return data
def auth_required(func):
@wraps(func)
def wrapper(*args, **kwargs):
token = request.headers.get('Authorization', '')
if token:
user = verify_token(token)
if user:
g.current_user = user
return func(*args, **kwargs)
return UNAUTHORIZED
return wrapper
def admin_required(func):
@wraps(func)
def wrapper(*args, **kwargs):
token = request.headers.get('Authorization', '')
if token:
user = verify_token(token)
if user and user['is_admin']:
g.current_user = user
return func(*args, **kwargs)
return FORBIDDEN
return wrapper
| {
"repo_name": "projectweekend/Flask-PostgreSQL-API-Seed",
"path": "app/utils/auth.py",
"copies": "1",
"size": "1410",
"license": "mit",
"hash": 677453778476030100,
"line_mean": 24.6363636364,
"line_max": 70,
"alpha_frac": 0.619858156,
"autogenerated": false,
"ratio": 4.0285714285714285,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5148429584571429,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request, g
from time import time
from app import app, redis
from app.utils.errors import TOO_MANY_REQUESTS
def rate_limit(limit=100, window=60):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
key = "{0}: {1}".format(request.remote_addr, request.path)
try:
remaining = limit - int(redis.get(key))
except (ValueError, TypeError):
remaining = limit
redis.set(key, 0)
expires_in = redis.ttl(key)
if not expires_in:
redis.expire(key, window)
expires_in = window
g.rate_limits = (limit, remaining-1, time()+expires_in)
if remaining > 0:
redis.incr(key, 1)
return func(*args, **kwargs)
return TOO_MANY_REQUESTS
return wrapper
return decorator
@app.after_request
def add_rate_limit_headers(response):
try:
limit, remaining, expires = map(int, g.rate_limits)
except (AttributeError, ValueError):
return response
else:
response.headers.add('X-RateLimit-Remaining', remaining)
response.headers.add('X-RateLimit-Limit', limit)
response.headers.add('X-RateLimit-Reset', expires)
return response
| {
"repo_name": "projectweekend/Flask-PostgreSQL-API-Seed",
"path": "app/utils/rate_limit.py",
"copies": "1",
"size": "1355",
"license": "mit",
"hash": -3914606792959529500,
"line_mean": 27.829787234,
"line_max": 70,
"alpha_frac": 0.5852398524,
"autogenerated": false,
"ratio": 4.081325301204819,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5166565153604818,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request, make_response, jsonify
from plato.api.models import User
def authenticate(f):
@wraps(f)
def decorated_function(*args, **kwargs):
response_object = {
'status': 'error',
'message': 'Something went wrong. Please contact us.'
}
code = 401
auth_header = request.headers.get('Authorization')
if not auth_header:
response_object['message'] = 'Provide a valid auth token'
code = 403
return make_response(jsonify(response_object)), code
auth_token = auth_header.split(' ')[1]
resp = User.decode_auth_token(auth_token)
if isinstance(resp, str):
response_object['message'] = resp
return make_response(jsonify(response_object)), code
user = User.query.filter_by(id=resp).first()
if not user or not user.active:
return make_response(jsonify(response_object)), code
return f(resp, *args, **kwargs)
return decorated_function
def is_admin(user_id):
user = User.query.filter_by(id=user_id).first()
if user.admin:
return True
return False
| {
"repo_name": "zhlooking/flask-microservices-users",
"path": "plato/api/utils.py",
"copies": "1",
"size": "1198",
"license": "mit",
"hash": -7523335296702650000,
"line_mean": 31.3783783784,
"line_max": 69,
"alpha_frac": 0.612687813,
"autogenerated": false,
"ratio": 4.033670033670034,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5146357846670033,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request, make_response
from .exceptions import ApiError
from .schemas import create_schema, ma_version_lt_300b7
def request_schema(schema_or_dict, extends=None, many=None, cache_schema=True, pass_data=False):
schema_ = create_schema(schema_or_dict, extends)
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
schema = cache_schema and schema_ or create_schema(schema_or_dict, extends)
if request.json is None:
# NOTE: this should be fixed with marshmallow 3 (and 2.16?)
raise ApiError('JSON data required')
data = schema.load(request.json, many=many)
if ma_version_lt_300b7:
data = data.data
if pass_data:
kwargs.update({'data' if pass_data is True else pass_data: data})
else:
kwargs.update(data)
return func(*args, **kwargs)
return wrapper
return decorator
def request_args_schema(schema_or_dict, extends=None, cache_schema=True, pass_data=False):
schema_ = create_schema(schema_or_dict, extends)
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
schema = cache_schema and schema_ or create_schema(schema_or_dict, extends)
data = schema.load(request.args)
if ma_version_lt_300b7:
data = data.data
if pass_data:
kwargs.update({'data' if pass_data is True else pass_data: data})
else:
kwargs.update(data)
return func(*args, **kwargs)
return wrapper
return decorator
def response_schema(schema_or_dict, extends=None, many=None, cache_schema=True):
schema_ = create_schema(schema_or_dict, extends)
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
schema = cache_schema and schema_ or create_schema(schema_or_dict, extends)
result = func(*args, **kwargs)
if isinstance(result, (list, tuple)) and (schema.many or many):
data = schema.dump(result, many=many)
else:
data = schema.dump(result, many=many)
if ma_version_lt_300b7:
data = data.data
return data
return wrapper
return decorator
def response_headers(headers={}):
"""
This decorator adds the headers passed in to the response
"""
# http://flask.pocoo.org/snippets/100/
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
resp = make_response(func(*args, **kwargs))
h = resp.headers
for header, value in headers.items():
h[header] = value
return resp
return wrapper
return decorator
def response_headers_no_cache(func):
@wraps(func)
@response_headers({
'Cache-Control': 'no-store',
'Pragma': 'no-cache',
})
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
| {
"repo_name": "vgavro/flask-vgavro-utils",
"path": "flask_vgavro_utils/decorators.py",
"copies": "1",
"size": "3120",
"license": "bsd-2-clause",
"hash": -3681102236099659300,
"line_mean": 30.8367346939,
"line_max": 96,
"alpha_frac": 0.583974359,
"autogenerated": false,
"ratio": 4.0519480519480515,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0009400522586246963,
"num_lines": 98
} |
from functools import wraps
from flask import request
from pydantic import ValidationError, create_model
ARG_LOCATIONS = {
"query": lambda: request.args,
"json": lambda: request.get_json(),
"form": lambda: request.form,
"headers": lambda: request.headers,
"cookies": lambda: request.cookies,
}
def validate_args(spec, location):
"""
A rough implementation of webargs using pydantic schemas. You can pass a
pydantic schema as spec or create it on the fly as follows:
@validate_args({"name": (str, None), "id": (int, None)}, location="query")
"""
if isinstance(spec, dict):
spec = create_model("", **spec)
schema = spec.schema()
props = schema.get("properties", {})
required = schema.get("required", [])
for k in props:
if k in required:
props[k]["required"] = True
props[k]["in"] = location
def decorator(func):
# Inject parameters information into the Flask-Restx apidoc attribute.
# Not really a good solution. See https://github.com/CTFd/CTFd/issues/1504
apidoc = getattr(func, "__apidoc__", {"params": {}})
apidoc["params"].update(props)
func.__apidoc__ = apidoc
@wraps(func)
def wrapper(*args, **kwargs):
data = ARG_LOCATIONS[location]()
try:
# Try to load data according to pydantic spec
loaded = spec(**data).dict(exclude_unset=True)
except ValidationError as e:
# Handle reporting errors when invalid
resp = {}
errors = e.errors()
for err in errors:
loc = err["loc"][0]
msg = err["msg"]
resp[loc] = msg
return {"success": False, "errors": resp}, 400
return func(*args, loaded, **kwargs)
return wrapper
return decorator
| {
"repo_name": "ajvpot/CTFd",
"path": "CTFd/api/v1/helpers/request.py",
"copies": "4",
"size": "1925",
"license": "apache-2.0",
"hash": -2452650351252771300,
"line_mean": 31.0833333333,
"line_max": 82,
"alpha_frac": 0.5667532468,
"autogenerated": false,
"ratio": 4.203056768558952,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00020080321285140563,
"num_lines": 60
} |
from functools import wraps
from flask import request
from sqlalchemy import or_
from sqlalchemy.orm import joinedload, contains_eager, attributes
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy.util import KeyedTuple
from .model import session_scope, Track, TrackInfo, Album, Artist, Cover
def limitoffset(query, skip, limit):
if skip is not None:
query = query.offset(skip)
if limit is not None:
query = query.limit(limit)
return query
class Typed:
types_whitelist = ['tags', 'folder']
def __init__(self, stype='tags'):
self.chosen_type = stype
if self.chosen_type not in Typed.types_whitelist:
self.chosen_type = Typed.types_whitelist[0]
def session_scope(self):
return session_scope(self.chosen_type)
def getartist(self, artist_id):
with self.session_scope() as session:
obj = session.query(Artist).get(artist_id)
session.expunge_all()
return obj
def getalbum(self, album_id=None, ffilter=None):
with self.session_scope() as session:
if album_id is not None:
obj = session.query(Album).get(album_id)
session.expunge_all()
return obj
elif ffilter is not None:
query = session.query(Album).join(Album.artist).options(contains_eager(Album.artist))
query = ffilter(query)
obj = query.one()
session.expunge_all()
return obj
return None
def getcoverbyalbumid(self, album_id):
with self.session_scope() as session:
try:
obj = session.query(Cover).join(Cover.albums).filter(Album.id == album_id).one()
session.expunge_all()
return obj
except NoResultFound:
return None
def gettrackinfo(self, trackinfo_id=None, ffilter=None):
with self.session_scope() as session:
if trackinfo_id is not None:
obj = session.query(TrackInfo).get(trackinfo_id)
session.expunge_all()
return obj
elif ffilter is not None:
query = session.query(TrackInfo).join(TrackInfo.album).join(Album.artist).options(
joinedload(TrackInfo.genre), contains_eager(TrackInfo.artist),
contains_eager(TrackInfo.album, Album.artist))
query = ffilter(query)
obj = query.one()
session.expunge_all()
return obj
return None
def gettrack(self, track_id=None, trackinfo_id=None):
with self.session_scope() as session:
if track_id is not None:
obj = session.query(Track).get(track_id)
session.expunge_all()
return obj
elif trackinfo_id is not None:
try:
obj = session.query(Track).join(Track.infos).filter(TrackInfo.id == trackinfo_id).one()
session.expunge_all()
return obj
except NoResultFound:
pass
return None
def gettrackfull(self, track_id):
with self.session_scope() as session:
try:
obj = session.query(TrackInfo).join(TrackInfo.album).join(Album.artist).options(
joinedload(TrackInfo.genre),
contains_eager(TrackInfo.artist),
contains_eager(TrackInfo.album, Album.artist)
).filter(TrackInfo.id == track_id).one()
session.expunge_all()
return obj
except NoResultFound:
return None
def listartists(self, ffilter=None, skip=None, limit=None):
with self.session_scope() as session:
query = session.query(Artist)
if ffilter is not None:
query = ffilter(query)
query = limitoffset(query.order_by(Artist.name), skip, limit)
qall = query.all()
session.expunge_all()
return qall
def listalbums(self, ffilter=None, skip=None, limit=None, order_by=(Artist.name, Album.year.desc())):
with self.session_scope() as session:
query = session.query(Album).join(Album.artist).options(contains_eager(Album.artist))
if ffilter is not None:
query = ffilter(query)
if order_by is not None:
query = limitoffset(query.order_by(*order_by), skip, limit)
else:
query = limitoffset(query, skip, limit)
qall = query.all()
session.expunge_all()
if len(qall) > 0 and isinstance(qall[0], KeyedTuple):
for i, item in enumerate(qall):
qall[i] = item[0]
return qall
def listalbumsbyartists(self, ffilter=None, skip=None, limit=None):
with self.session_scope() as session:
query = session.query(Artist).join(Artist.albums).options(contains_eager(Artist.albums, Album.artist))
if ffilter is not None:
query = ffilter(query)
query = limitoffset(query.order_by(Artist.name, Album.year.desc()), skip, limit)
qall = query.all()
session.expunge_all()
return qall
def listtracks(self, ffilter=None, skip=None, limit=None):
with self.session_scope() as session:
query = session.query(TrackInfo).join(TrackInfo.album).join(Album.artist).options(
contains_eager(TrackInfo.artist), contains_eager(TrackInfo.album, Album.artist))
if ffilter is not None:
query = ffilter(query)
query = limitoffset(query.order_by(TrackInfo.trackno), skip, limit)
qall = query.all()
session.expunge_all()
return qall
def counttracks(self, ffilter=None):
with self.session_scope() as session:
query = session.query(TrackInfo)
if ffilter is not None:
query = ffilter(query)
return query.count()
def countalbums(self, ffilter=None):
with self.session_scope() as session:
query = session.query(Album)
if ffilter is not None:
query = ffilter(query)
return query.count()
def listtracksbyalbums(self, ffilter=None, skip=None, limit=None):
with self.session_scope() as session:
query = session.query(Album).join(Album.tracks).outerjoin(TrackInfo.genre).options(
contains_eager(Album.tracks, TrackInfo.album, Album.artist), joinedload(Album.tracks, TrackInfo.genre))
if ffilter is not None:
query = ffilter(query)
query = limitoffset(query.order_by(Album.year.desc(), TrackInfo.trackno), skip, limit)
qall = query.all()
# Force artist population
for x in qall:
for y in x.tracks:
attributes.set_committed_value(y, 'album', x)
attributes.set_committed_value(y, 'artist', x.artist)
session.expunge_all()
return qall
def listtracksbyalbumsbyartists(self, ffilter=None, skip=None, limit=None,
order_by=(Artist.name, Album.year.desc(), TrackInfo.trackno, TrackInfo.name)):
with self.session_scope() as session:
query = session.query(Artist).join(Artist.albums).join(Album.tracks).join(TrackInfo.track).options(
contains_eager(Artist.albums, Album.tracks))
if ffilter is not None:
query = ffilter(query)
query = limitoffset(query.order_by(*order_by), skip, limit)
qall = query.all()
# Force artist population
for x in qall:
for y in x.albums:
attributes.set_committed_value(y, 'artist', x)
for z in y.tracks:
attributes.set_committed_value(z, 'album', y)
attributes.set_committed_value(z, 'artist', x)
session.expunge_all()
return qall
def searchartists(self, term, skip=None, limit=None):
ffilter = lambda query: query.filter(Artist.name.contains(term))
return self.listartists(ffilter, skip, limit)
def searchalbums(self, term, skip=None, limit=None):
ffilter = lambda query: query.filter(Album.name.contains(term))
return self.listalbums(ffilter, skip, limit)
def search(self, term, artists=True, albums=True, tracks=True, skip=None, limit=None):
def ffilter(query):
filters = []
if artists:
filters.append(Artist.name.contains(term))
if albums:
filters.append(Album.name.contains(term))
if tracks:
filters.append(TrackInfo.name.contains(term))
if len(filters) > 0:
query = query.filter(or_(*filters))
return query
return self.listtracksbyalbumsbyartists(ffilter, skip, limit)
def typed_fct(func):
@wraps(func)
def wrapper(*arg, **kwargs):
stype = request.args.get('type', 'tags')
return func(Typed(stype), *arg, **kwargs)
return wrapper
| {
"repo_name": "magne4000/festival",
"path": "festivallib/request.py",
"copies": "1",
"size": "9383",
"license": "mit",
"hash": -5717507041790010000,
"line_mean": 39.7956521739,
"line_max": 119,
"alpha_frac": 0.5738036875,
"autogenerated": false,
"ratio": 4.118964003511852,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5192767691011853,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request
from app.main.service.auth_helper import Auth
def token_required(f):
@wraps(f)
def decorated(*args, **kwargs):
data, status = Auth.get_logged_in_user(request)
token = data.get('data')
if not token:
return data, status
return f(*args, **kwargs)
return decorated
def admin_token_required(f):
@wraps(f)
def decorated(*args, **kwargs):
data, status = Auth.get_logged_in_user(request)
token = data.get('data')
if not token:
return data, status
admin = token.get('permission_level')
if not admin:
response_object = {
'status': 'fail',
'message': 'admin token required'
}
return response_object, 401
if admin == 2 or admin == 3:
return f(*args, **kwargs)
else:
response_object = {
'status': 'fail',
'message': 'admin token required'
}
return response_object, 401
return decorated
def superuser_token_required(f):
@wraps(f)
def decorated(*args, **kwargs):
data, status = Auth.get_logged_in_user(request)
token = data.get('data')
if not token:
return data, status
admin = token.get('permission_level')
if not admin:
response_object = {
'status': 'fail',
'message': 'superuser token required'
}
return response_object, 401
if admin == 3:
return f(*args, **kwargs)
else:
response_object = {
'status': 'fail',
'message': 'superuser token required'
}
return response_object, 401
return decorated
| {
"repo_name": "i-am-dev/DojoManager",
"path": "app/main/util/decorator.py",
"copies": "1",
"size": "1871",
"license": "mit",
"hash": 4084493352168170500,
"line_mean": 22.3875,
"line_max": 55,
"alpha_frac": 0.5168359166,
"autogenerated": false,
"ratio": 4.423167848699763,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5440003765299763,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request
from community_share.authorization import get_requesting_user
from community_share.routes import base_routes
def api_path(path, query_args):
query = '&'.join(['{}={}'.format(name, query_args[name]) for name in query_args])
return '{base_url}rest/{path}/{query}'.format(
base_url=request.url_root,
path=path,
query='?{}'.format(query) if query is not '' else ''
)
def needs_auth(auth_level='user'):
def needs_auth_decorator(f):
@wraps(f)
def auth_check(*args, **kwargs):
user = get_requesting_user()
if user is None:
return base_routes.make_not_authorized_response()
if 'admin' == auth_level and not user.is_administrator:
return base_routes.make_not_authorized_response()
return f(*args, requester=user, **kwargs)
return auth_check
return needs_auth_decorator
def needs_admin_auth():
return needs_auth('admin')
| {
"repo_name": "seanastephens/communityshare",
"path": "community_share/flask_helpers.py",
"copies": "1",
"size": "1031",
"license": "mpl-2.0",
"hash": -2090685932945497600,
"line_mean": 25.4358974359,
"line_max": 85,
"alpha_frac": 0.6236663434,
"autogenerated": false,
"ratio": 3.8185185185185184,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4942184861918518,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request
from flask.ext.restful import Api
from flask.ext.restful.reqparse import RequestParser
def patched_to_marshallable_type(obj):
"""adds __marshallable__ support; see https://github.com/twilio/flask-restful/pull/32"""
if obj is None:
return None # make it idempotent for None
if hasattr(obj, '__getitem__'):
return obj # it is indexable it is ok
if hasattr(obj, '__marshallable__'):
return obj.__marshallable__()
return dict(obj.__dict__)
class BetterErrorHandlingApi(Api):
# HACK: see https://github.com/twilio/flask-restful/issues/8
# and https://github.com/twilio/flask-restful/pull/29
def __init__(self, app, prefix='', default_mediatype='application/json',
decorators=None):
self.saved_handle_exception = app.handle_exception
self.saved_handle_user_exception = app.handle_user_exception
super(BetterErrorHandlingApi, self).__init__(app, prefix, default_mediatype, decorators)
app.handle_exception = self.handle_exception
app.handle_user_exception = self.handle_user_exception
self.endpoints = set()
def add_resource(self, resource, *urls, **kwargs):
endpoint = kwargs.setdefault('endpoint', resource.__name__.lower())
self.endpoints.add(endpoint)
return super(BetterErrorHandlingApi, self).add_resource(resource, *urls, **kwargs)
def handle_exception(self, e):
return self.handle_error(self.saved_handle_exception, e)
def handle_user_exception(self, e):
return self.handle_error(self.saved_handle_user_exception, e)
def handle_error(self, original, e):
rv = original(e) # call original error handler, so any side-effect causing handling (sentry, etc) will happen
if not request.url_rule or request.url_rule.endpoint not in self.endpoints:
return rv
return super(BetterErrorHandlingApi, self).handle_error(e)
def parse_with(*arguments, **kwargs):
"""This decorator allows you to easily augment any method (typically a
view method) to access reqparse based arguments, i.e.:
class Users(Resource):
@parse_with(Argument('profession'))
def post(self, params, username):
create_new_user(username, params.profession)
return 'CREATED', 201
api.add_resource(Users, '/<username>', endpoint='users')
"""
parser = kwargs.pop('parser', RequestParser())
if kwargs: # mimic py3k style named-arguments after *args, i.e., def f(a, *b, c=1)
raise TypeError("unexpected keyword argument '%s'" % (kwargs.popitem()[0],))
for argument in arguments:
parser.args.append(argument)
def decor(func):
@wraps(func)
def inner(self, *args, **kwargs):
return func(self, parser.parse_args(), *args, **kwargs)
return inner
return decor
| {
"repo_name": "paulvisen/flask-todo",
"path": "utils/flaskutils/restful.py",
"copies": "2",
"size": "2942",
"license": "mit",
"hash": 6990349651556561000,
"line_mean": 42.2647058824,
"line_max": 117,
"alpha_frac": 0.6597552685,
"autogenerated": false,
"ratio": 3.8863936591809773,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5546148927680977,
"avg_score": null,
"num_lines": null
} |
from functools import wraps
from flask import request, session
from conditional.util.ldap import ldap_is_active, ldap_is_alumni, \
ldap_is_eboard, ldap_is_eval_director, \
ldap_is_financial_director, ldap_get_member, ldap_is_current_student
def webauth_request(func):
@wraps(func)
def wrapped_func(*args, **kwargs):
user_name = request.headers.get('x-webauth-user')
account = ldap_get_member(user_name)
is_active = ldap_is_active(account)
is_alumni = ldap_is_alumni(account)
is_eboard = ldap_is_eboard(account)
is_financial = ldap_is_financial_director(account)
is_eval = ldap_is_eval_director(account)
return func({"user_name": user_name,
"is_active": is_active,
"is_alumni": is_alumni,
"is_eboard": is_eboard,
"is_financial": is_financial,
"is_eval": is_eval}, *args, **kwargs)
return wrapped_func
def get_user(func):
@wraps(func)
def wrapped_function(*args, **kwargs):
username = str(session["userinfo"].get("preferred_username", ""))
account = ldap_get_member(username)
current_student = ldap_is_current_student(account)
user_dict = {
'username': username,
'account': account,
'student': current_student
}
kwargs["user_dict"] = user_dict
return func(*args, **kwargs)
return wrapped_function
| {
"repo_name": "ComputerScienceHouse/conditional",
"path": "conditional/util/auth.py",
"copies": "1",
"size": "1499",
"license": "mit",
"hash": 1636267782973045800,
"line_mean": 30.8936170213,
"line_max": 73,
"alpha_frac": 0.5917278185,
"autogenerated": false,
"ratio": 3.6207729468599035,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4712500765359904,
"avg_score": null,
"num_lines": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.