def filter_or_exclude_by_date(negate, klass, **kwargs):
filter_kwargs = {}
for key, date_value in kwargs.items():
assert isinstance(date_value, date)
date_range = (
timezone.make_aware(datetime.combine(date_value, time.min), timezone.get_current_timezone()),
timezone.make_aware(datetime.combine(date_value, time.max), timezone.get_current_timezone())
)
filter_kwargs['%s__range' % key] = date_range
if negate:
return _get_queryset(klass).exclude(**filter_kwargs)
else:
return _get_queryset(klass).filter(**filter_kwargs)
def get_child_model(self):
"""
Attempts to determine if an inherited model record exists.
New child relationships can be added though the inner class Inheritance.
class Model(ChildAwareModel):
...
class Inheritance:
children = ( 'yourapp.models.ChildModel', )
"""
def get_child_module(module, list):
if len(list) > 1:
return get_child_module(getattr(module, list[0:1][0]), list[1:])
else:
return getattr(module, list[0])
if hasattr(self, 'Inheritance'):
children = getattr(self.Inheritance, 'children', [])
for c in children:
components = c.split('.')
m = __import__(components[0])
klass = get_child_module(m, components[1:])
qs = _get_queryset(klass)
try:
child = qs.get( **{ 'pk':self.pk } )
return child
except qs.model.DoesNotExist:
pass
return None
def muecke_get_object(klass, *args, **kwargs):
"""
Uses get() to return an object, or raises a Http404 exception if the object
does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), an MultipleObjectsReturned will be raised if more than one
object is found.
"""
cache_key = "%s-%s-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, klass.__name__.lower(), kwargs.values()[0])
object = cache.get(cache_key)
if object is not None:
return object
queryset = _get_queryset(klass)
try:
object = queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
else:
cache.set(cache_key, object)
return object
def get_object_or_404(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs), True
except queryset.model.DoesNotExist:
m = Meteora(False,"No %s not matches the given query." % queryset.model._meta.object_name)
return m.json_response(), False
def _get_object_list(klass, *args, **kwargs):
"""
Builds on Django's private method _get_queryset
Helps to DRY up a few things here
"""
queryset = _get_queryset(klass)
return list(queryset.filter(*args, **kwargs))
def get_object_or_empty(klass, *args, **kwargs):
"""Raises ApiEmpty if the object cannot be found"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise ApiEmpty
def get_list_or_empty(klass, *args, **kwargs):
"""Raises ApiEmpty if the list cannot be found"""
queryset = _get_queryset(klass)
obj_list = list(queryset.filter(*args, **kwargs))
if not obj_list:
raise ApiEmpty
return obj_list
def _get_model(self, model, **kw):
try:
return _get_queryset(model).get(**kw)
except ObjectDoesNotExist:
raise APIFault('Reference given does not match any data.', http_code=410)
except MultipleObjectsReturned:
raise APIFault('Your reference was bad, multiple records returned from lookup.', http_code=400)
def get_or_none(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def setup_queryset_batches(self):
self.batches = self.queryset_batches
from django.conf import settings
if settings.DEBUG:
logging.warn("Warning: DEBUG is on. django.db.connection.queries may use up a lot of memory.")
# Get querysets corresponding to managers
from django.shortcuts import _get_queryset
self.queryset = queryset = _get_queryset(self.sequence)
from django.core.paginator import Paginator
limited = queryset if self.limit is None else queryset[: self.limit]
if self.stable_ids:
# Get a snapshot of all the ids that match the query
logging.info("Getting list of matching objects")
ids = list(limited.values_list(queryset.model._meta.pk.name, flat=True))
self.paginator = Paginator(ids, self.batch_size)
self.has_ids = True
else:
self.paginator = Paginator(limited, self.batch_size)
self.has_ids = False
self.status.total = self.paginator.count
def read(self, request, *args, **kwargs):
"""
Retrieves the number of objects.
"""
if not self.has_model():
return rc.NOT_IMPLEMENTED
# Initialization
queryset = _get_queryset(self.model)
# Filtering
filters, excludes = {}, {}
for k, v in request.GET.iteritems():
if k.startswith('filter_'):
filters[k[7:]] = v
if k.startswith('exclude_'):
excludes[k[8:]] = v
queryset = queryset.filter(*filters.items()).exclude(*excludes.items())
# Ordering
if 'order_by' in request.GET:
order_bys = request.GET['order_by'].split(',')
queryset = queryset.order_by(*order_bys)
# Counting
counter = queryset.count()
logger.debug(u'Count: %s objects' % counter)
return counter
def get_or_create(klass, defaults=None, **kwargs):
queryset = _get_queryset(klass)
objs = queryset.filter(**kwargs)
if len(objs) > 0:
return objs[0], False
else:
return queryset.get_or_create(defaults=defaults, **kwargs)
def first_object_or_404(klass, *args, **kwargs):
queryset = _get_queryset(klass)
objs = queryset.filter(*args, **kwargs)
if len(objs) > 0:
return objs[0]
else:
raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)
def get_object(request, klass, id_tag, query={}):
klass = _get_queryset(klass)
try:
id = int(request.GET[tag])
except:
raise Http404
return get_object_or_404(klass, pk=id, **query)
def filter_objects_by_form(request, klass, form_class,
form_fltr={}, def_fltr={}, com_fltr={},
pre_filter=None, method='POST'):
klass = _get_queryset(klass)
okay = False
if request.method == method:
form = form_class(request.POST if (method == 'POST') else request.GET)
if form.is_valid():
q_fltr = []
fltr = {}
for field, form_key in form_fltr.iteritems():
val = form.cleaned_data[form_key]
if val:
fltr[field] = val
if pre_filter:
pre_filter(form, fltr, q_fltr)
if fltr or q_fltr:
fltr.update(com_fltr)
qs = klass.filter(*q_fltr, **fltr).distinct()
okay = True
else:
form = form_class()
if not okay:
if def_fltr:
fltr = dict(def_fltr) if com_fltr else def_fltr
fltr.update(com_fltr)
qs = klass.filter(**fltr).distinct()
else:
qs = klass.all(**com_fltr)
return qs, form
def latest_or_empty(klass, field_name=None, direction="-"):
order_by = field_name
queryset = _get_queryset(klass)._clone()
try:
return queryset.latest(order_by)
except queryset.model.DoesNotExist:
return {}
def get_object_or_json404(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise JsonNotFound()
def get_object_or_403(klass, *args, **kwargs):
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return HttpResponse(status=403)
def filter_by_access(user, queryset, read=True, write=False, manage=False):
user = user or AnonymousUser()
queryset = _get_queryset(queryset)
if not (read or write or manage) or user.is_superuser: # nothing to do
return queryset
model_type = ContentType.objects.get_for_model(queryset.model)
usergroups_q = Q(usergroup__in=ExtendedGroup.objects.get_extra_groups(user))
if not user.is_anonymous():
usergroups_q = usergroups_q | Q(usergroup__in=user.groups.all())
user_q = Q(user__isnull=True, usergroup__isnull=True) if user.is_anonymous() else Q(user=user)
owner_q = Q(owner=user) if 'owner' in (f.name for f in queryset.model._meta.fields) and not user.is_anonymous() else None
def build_query(**kwargs):
(field, check) = kwargs.popitem()
if not check:
return Q()
user_allowed_q = Q(id__in=AccessControl.objects.filter(user_q, content_type__id=model_type.id,
**{field: True}).values('object_id'))
user_denied_q = Q(id__in=AccessControl.objects.filter(user_q, content_type__id=model_type.id,
**{field: False}).values('object_id'))
group_allowed_q = Q(id__in=AccessControl.objects.filter(usergroups_q, content_type__id=model_type.id,
**{field: True}).values('object_id'))
group_denied_q = Q(id__in=AccessControl.objects.filter(usergroups_q, content_type__id=model_type.id,
**{field: False}).values('object_id'))
result = ((group_allowed_q & ~group_denied_q) | user_allowed_q) & ~user_denied_q
if owner_q:
result = owner_q | result
return result
return queryset.filter(build_query(read=read), build_query(write=write), build_query(manage=manage)).distinct()
def get_object_or_make(klass, *args, **kwargs):
"""
The long lost sibling of Django's `get_or_create`.
Attempts to look for and get a model, if none is found, just populates
the model class with the look up fields.
Example:
>>> instance, exists = get_object_or_make(Post, url="http://trackmaven.com")
>>> instance.pk
1
>>> exists
True
Returns:
object: The django model passed in
exists (boolean): An boolean specifying whether an object was found.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs), True
except queryset.model.DoesNotExist:
return klass(*args, **kwargs), False
def cache_get_object(klass, *args, **kwargs):
"""
Uses get() to return an object, or returns None if the object
does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), an MultipleObjectsReturned will be raised if more than one
object is found.
"""
cache_key = make_cache_key(klass, **kwargs)
object = cache.get(cache_key)
if object is not None:
return object
queryset = _get_queryset(klass)
try:
object = queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
else:
cache.set(cache_key, object)
return object
def lfs_get_object_or_404(klass, *args, **kwargs):
"""
Uses get() to return an object, or raises a Http404 exception if the object
does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), an MultipleObjectsReturned will be raised if more than one
object is found.
"""
cache_key = "%s-%s-%s" % (force_str(settings.CACHE_MIDDLEWARE_KEY_PREFIX), klass.__name__.lower(),
force_str(kwargs.values()[0]))
cache_key = hashlib.md5(cache_key).hexdigest()
object = cache.get(cache_key)
if object is not None:
return object
queryset = _get_queryset(klass)
try:
object = queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)
else:
cache.set(cache_key, object)
return object
def filter_hidden(request, queryset_or_model):
"""
Return queryset for model, manager or queryset, filtering hidden objects for non staff users.
"""
queryset = _get_queryset(queryset_or_model)
if request.user.is_staff:
return queryset
return queryset.filter(hidden=False)
def accessible_ids(user, queryset, read=True, write=False, manage=False):
queryset = _get_queryset(queryset)
key = 'accessible_ids-%d-%s-%d%d%d' % (user.id if user and user.id else 0,
md5.new(str(queryset.query)).hexdigest(),
read, write, manage)
def get_ids():
return list(filter_by_access(user, queryset, read, write, manage).values_list('id', flat=True))
return get_cached_value(key, get_ids, model_dependencies=[queryset.model, AccessControl])
def get_object_or_None(klass, *args, **kwargs):
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.select_related().get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_by_str_id(cls, str):
queryset = _get_queryset(cls)
try:
id = int(str)
except cls.model.DoesNotExist:
raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)
return get_object_or_404(cls, pk=id)
def get_object_or_new(klass, *args, **kwargs):
# bitbucket.org/offline/django-annoying/src/tip/annoying/functions.py
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return klass()
def get_object_or_None(klass, **kwargs):
queryset = _get_queryset(klass)
try:
result = queryset.get(**kwargs)
except queryset.model.DoesNotExist:
result = None
return result
def get_object_or_none(klass, *args, **kwargs):
"""
Calls get() on a given model manager, but it returns None instead of the model’s DoesNotExist exception.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except:
return None
def get_object_or_none(model, *args, **kwargs):
"""
Возвращает instance модели или None
"""
queryset = _get_queryset(model)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_object_or_none(klass, *ar, **kw):
"""
Returns object if it exists or None.
kclass may be Model, Manager, Object.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*ar, **kw)
except queryset.model.DoesNotExist:
return None
def get_first_or_None(klass, *args, **kwargs):
"""
Similar to ``django.shortcuts.get_object_or_404`` but tries to fetch
first item from the query and if it does *NOT* exist None is returned
rather than raising exception.
"""
queryset = _get_queryset(klass)
try:
return queryset[0]
except IndexError:
return None
def get_object_or_403(klass, *args, **kwargs):
'''
Return a single object from the given model or queryset based on the query
params, otherwise raise an exception that will return in a 403 response.
'''
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist, e:
raise PermissionDenied(*e.args)
def get_object_or_None(klass, *args, **kwargs):
"""
Uses get() to return an object or None if the object does not exist.
klass may be a Model, Manager, or QuerySet object.
All other passed arguments and keyword arguments are used in the get() query.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_first_or_None(model, *args, **kwargs):
"""
see GET_FIRST
"""
queryset = _get_queryset(model)
try:
return queryset.filter(*args, **kwargs)[0]
except IndexError:
return None
except:
raise
def get_object_or_None(klass, *args, **kwargs):
""" Usage:
from gestorpsi.util.views import get_object_or_None
...
object = get_object_or_None(Class, pk=id)
"""
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_objects_and_perms_for_user(user, codenames, klass, use_groups=True, any_perm=False):
""" Similar to what guardian's get_objects_for_user method does,
this method return a dictionary of object IDs (!) of model klass
objects with the permissions the user has on them associated.
These permissions may result from explicit user permissions or
implicit group ones. Parts of the source code are takes from
django-guardian. Note, that there an object list is returned. In
contrast this method returns object IDs and the permissions on
the actual objects.
"""
# Get QuerySet on and ContentType of the model
queryset = _get_queryset(klass)
ctype = ContentType.objects.get_for_model(queryset.model)
# A super user has all permissions available on all the objects
# of a model.
if user.is_superuser:
# Get all permissions for the model
perms = get_perms_for_model(klass)
permNames = set(perm.codename for perm in perms)
pk_dict = {}
for p in queryset:
pk_dict[p.id] = permNames
return pk_dict
# Extract a list of tuples that contain an object's primary
# key and a permission codename that the user has on them.
user_obj_perms = UserObjectPermission.objects\
.filter(user=user)\
.filter(permission__content_type=ctype)\
.filter(permission__codename__in=codenames)\
.values_list('object_pk', 'permission__codename')
data = list(user_obj_perms)
if use_groups:
groups_obj_perms = GroupObjectPermission.objects\
.filter(group__user=user)\
.filter(permission__content_type=ctype)\
.filter(permission__codename__in=codenames)\
.values_list('object_pk', 'permission__codename')
data += list(groups_obj_perms)
# sorting/grouping by pk (first in result tuple)
keyfunc = lambda t: int(t[0])
data = sorted(data, key=keyfunc)
# Create the result dictionary, associating one object id
# with a set of permissions the user has for it.
pk_dict = {}
for pk, group in groupby(data, keyfunc):
obj_codenames = set((e[1] for e in group))
if any_perm or codenames.issubset(obj_codenames):
pk_dict[pk] = obj_codenames
return pk_dict
def get_object_or_none(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except AttributeError:
klass__name = klass.__name__ if isinstance(klass, type) else klass.__class__.__name__
raise ValueError(
"First argument to get_object_or_none() must be a Model, Manager, "
"or QuerySet, not '%s'." % klass__name
)
except queryset.model.DoesNotExist:
return None
def get_list_or_empty(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
obj_list = list(queryset.filter(*args, **kwargs))
except AttributeError:
klass__name = klass.__name__ if isinstance(
klass, type) else klass.__class__.__name__
raise ValueError(
"First argument to get_list_or_empty() must be a Model, Manager, or "
"QuerySet, not '%s'." % klass__name)
if not obj_list:
return []
return obj_list
def filter_hidden(request, queryset_or_model):
"""
Return queryset for model, manager or queryset, filtering hidden objects for non staff users.
"""
queryset = _get_queryset(queryset_or_model)
if request.user.is_anonymous():
return queryset.filter(hidden=False)
q1 = Q(hidden=False)
user_groups = request.user.groups.all()
q2 = Q(hidden=True) & Q(visible_to_user=request.user)
q3 = Q(hidden=True) & Q(visible_to_group__in=user_groups)
return queryset.filter(q1|q2|q3).distinct()
def get_list_or_404(klass, *args, **kwargs):
"""
Uses filter() to return a list of objects, or raise a NotFound exception if
the list is empty.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the filter() query.
"""
queryset = _get_queryset(klass)
obj_list = list(queryset.filter(*args, **kwargs))
if not obj_list:
raise http.NotFound()
return obj_list
def get_object_or_none(klass, *args, **kwargs):
"""
Uses get() to return an object or None if the object does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), a MultipleObjectsReturned will be raised if more than one
object is found.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_object_or_none(cls, **kwargs):
"""
Returns model instance or None if not found.
:param cls: Class or queryset
:param kwargs: Filters for get() call
:return: Object or None
"""
from django.shortcuts import _get_queryset
qs = _get_queryset(cls)
try:
return qs.get(**kwargs)
except qs.model.DoesNotExist:
return None
def get_object_or_404_custom_isTemporary(klass, *args, **kwargs):
queryset = _get_queryset(klass)
klass__name = klass.__name__ if isinstance(
klass, type) else klass.__class__.__name__
if not hasattr(queryset, 'get'):
raise DDCustomException(
"First argument to get_object_or_404() must be a Model, Manager, "
"or QuerySet, not '%s'." % klass__name)
try:
return queryset.get(*args, **kwargs)
except:
raise DDCustomException(f"{kwargs}를 만족하는 {klass__name} 객체가 없습니다.",
status_code=status.HTTP_404_NOT_FOUND)
def get_queryset_size(klass, *args, **kwargs):
queryset = _get_queryset(klass)
try:
obj_query = queryset.filter(*args, **kwargs)
except AttributeError:
klass__name = klass.__name__ if isinstance(
klass, type) else klass.__class__.__name__
raise ValueError(
"First argument get_queryset_size() must be a Model, Manager, or "
"QuerySet, not '%s'." % klass__name)
if not obj_query:
return 0
return obj_query.count()
def get_object_or_400(klass, *args, **kwargs):
'''
Return a single object from the given model or queryset based on the query
params, otherwise raise an exception that will return in a 400 response.
'''
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist as e:
raise ParseError(*e.args)
except queryset.model.MultipleObjectsReturned as e:
raise ParseError(*e.args)
def get_list_or_false(klass, *args, **kwargs):
"""
Uses filter() to return a list of objects, or False if
the list is empty.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the filter() query.
"""
queryset = _get_queryset(klass)
obj_list = list(queryset.filter(*args, **kwargs))
if not obj_list:
return False
return obj_list
def get_earliest_objects_or_none(klass, *args, **kwargs):
""" Return the earliest model if exists else none """
queryset = _get_queryset(klass)
if not hasattr(queryset, 'get'):
klass__name = klass.__name__ if isinstance(
klass, type) else klass.__class__.__name__
raise ValueError(
"First argument to get_earliest_objects_or_none() must be a Model, Manager, "
"or QuerySet, not '%s'." % klass__name)
try:
return queryset.filter(*args, *kwargs).earliest('id')
except queryset.model.DoesNotExist:
return None
def get_or_raise(klass, *args, **kwargs):
queryset = _get_queryset(klass)
if not hasattr(queryset, "get"):
klass__name = (klass.__name__ if isinstance(klass, type) else
klass.__class__.__name__)
raise ValueError(
"First argument to get_or_raise() must be a Model, Manager, "
"or QuerySet, not '%s'." % klass__name)
error_msg = kwargs.pop("error_msg", "")
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise ResourceDoesNotExist(error_msg)
def get_visible_object_or_404(klass, *args, **kwargs):
"""
Convenience replacement for `get_object_or_404` that automatically finds
and returns only the *visible* copy of publishable items, or raises
`Http404` if a visible copy is not available even when a draft copy is
available.
"""
qs = _get_queryset(klass)
# If class is publishable, find only *visible* objects
try:
qs = qs.visible()
except AttributeError:
pass # Ignore error calling `visible()` on unpublishable class
return get_object_or_404(qs, *args, **kwargs)
def get_queryset_or_404(klass, *args, **kwargs):
"""
This is an alternative for get_list_or_404 in django.shortcuts
For when you need to handle results using sort_by(), filter(), exclude() ...etc...
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the filter() query.
"""
queryset = _get_queryset(klass)
obj_queryset = queryset.filter(*args, **kwargs)
if not obj_queryset.count() > 0:
raise Http404('No %s matches the given query.' %
queryset.model._meta.object_name)
return obj_queryset
def read(self, request, *args, **kwargs):
"""
Retrieves an object or a list of objects.
"""
if not self.has_model():
return rc.NOT_IMPLEMENTED
logger.debug('Args: %s' % str(args))
logger.debug('Kwargs: %s' % str(kwargs))
if list(kwargs.values()) != [None]:
# Returns a single object
return [self._get_object(self.model, *args, **kwargs)]
# Initialization
queryset = _get_queryset(self.model)
logger.debug('Before filters: %s' % str(queryset))
# Filtering
filters, excludes = {}, {}
for k, v in request.GET.items():
if k.startswith('filter_'):
filters[k[7:]] = v
if k.startswith('exclude_'):
excludes[k[8:]] = v
queryset = queryset.filter(*list(filters.items())).exclude(
*list(excludes.items()))
logger.debug('Filters: %s' % str(filters))
logger.debug('Excludes: %s' % str(excludes))
logger.debug('After filters: %s' % str(queryset))
# Ordering (test custom parameters' name)
if 'order' in request.GET:
order_bys = request.GET['order'].split(',')
queryset = queryset.order_by(*order_bys)
# Slicing
limit_start = int(request.GET.get('limit_start', 0))
limit_stop = request.GET.get('limit_stop', False) and int(
request.GET['limit_stop']) or None
queryset = queryset[limit_start:limit_stop]
obj_list = list(queryset)
if not obj_list:
raise Http404('No %s matches the given query.' %
queryset.model._meta.object_name)
logger.debug('Objects: %s retrieved' % [str(obj) for obj in obj_list])
return queryset
def get_object_or_404(klass, *args, **kwargs):
"""
Similar to `django.shortcuts.get_object_or_404` but raises NotFound and produces a more verbose error message.
"""
from django.shortcuts import _get_queryset
from rest_framework.exceptions import NotFound
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist as e:
error = e
except queryset.model.MultipleObjectsReturned as e:
error = e
message = f"{error} Lookup parameters: args={args} kwargs={kwargs}"
raise NotFound(message)
def get_objects_for_user(user, klass, perms):
qs = _get_queryset(klass)
if not user.is_active or user.is_anonymous:
return qs.none()
if user.is_superuser:
return qs
if isinstance(perms, six.string_types):
perms = [perms]
codenames = set()
for perm in perms:
if '.' in perm:
_, codename = perm.split('.', 1)
else:
codename = perm
codenames.add(codename)
roles = get_user_roles(user)
ctype = ContentType.objects.get_for_model(qs.model)
owned_codenames = []
if len(codenames):
owned_codenames = Permission.objects.filter(roles__in=roles).values_list('codename', flat=True)
role_ids = set()
org = user.user_profile.current_organization
if org is not None:
# Because of UUIDs we have to first save the IDs in
# memory and then query against that list, see
# https://stackoverflow.com/questions/50526873/
if not len(set(codenames).difference(set(owned_codenames))):
generic_objects = GroupGenericObjects.objects.filter(content_type=ctype, group=org)
role_ids = set(generic_objects.values_list('object_id', flat=True))
groups = get_user_groups(user)
group_ids = set(GroupObjectPermission.objects.filter(group__essauth_group__in=groups,
permission__codename__in=codenames)
.values_list('object_pk', flat=True))
user_ids = set(UserObjectPermission.objects.filter(user=user, permission__codename__in=codenames)
.values_list('object_pk', flat=True))
all_ids = role_ids | group_ids | user_ids
return qs.filter(pk__in=all_ids)
def get_object_or_none(klass, *args, **kwargs):
"""
Возвращает instance материала если находит, либо None
Сомнительный метод
вместо:
-- get_object_or_none(MyModel, field1=value1, field2=value2)
лучше использовать
-- MyModel.objects.filter(MyModel, field1=value1, field2=value2).first()
или код в этом методе заменить
-- return _get_queryset(klass).filter(*args, **kwargs).first()
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_object_or_none(models, *args, **kwargs):
"""
:param models: models
:return: 存在则返回对象，不存在则返回None
"""
queryset = _get_queryset(models)
try:
return queryset.get(*args, **kwargs)
except AttributeError:
models__name = models.__name__ if isinstance(
models, type) else models.__class__.__name__
raise ValueError(
"First argument to get_object_or_none() must be a Model, Manager, "
"or QuerySet, not '%s'." % models__name)
except queryset.model.DoesNotExist:
return None
def get_object_or_400(klass, *args, **kwargs):
"""
# `get_object_or_404`의 수정판
* 존재하지 않으면 400
"""
queryset = _get_queryset(klass)
if not hasattr(queryset, "get"):
klass__name = (klass.__name__ if isinstance(klass, type) else
klass.__class__.__name__)
raise ValueError(
"First argument to get_object_or_400() must be a Model, Manager, "
"or QuerySet, not '%s'." % klass__name)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
raise ValidationError("해당 객체가 없습니다.")
def get_object_or_none(klass, *args, **kwargs):
"""
Возвращает объект или None, если объект не существует.
klass может быть Model, Manager, или объектом QuerySet. Все остальные
переданные параметры используются для запроса get().
Замечание: Возвращает None, если найдено более одного объекта.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
except queryset.model.MultipleObjectsReturned:
return None
def get_object_or_None(klass, *args, **kwargs):
"""
function def taken from: http://skorokithakis.github.io/django-annoying/
Uses get() to return an object or None if the object does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), a MultipleObjectsReturned will be raised if more than one
object is found.
"""
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist:
return None
def get_latest_object_or_404(klass, *args, **kwargs):
"""
Uses get().latest() to return object, or raises a Http404 exception if
the object does not exist.
klass may be a Model, Manager, or QuerySet object. All other passed
arguments and keyword arguments are used in the get() query.
Note: Like with get(), an MultipleObjectsReturned will be raised if more than one
object is found.
"""
queryset = _get_queryset(klass)
try:
return queryset.filter(*args, **kwargs).latest()
except queryset.model.DoesNotExist:
raise Http404('No %s matches the given query.' %
queryset.model._meta.object_name)
