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)