def get_fields(cls): """ 主要包括'Meta.fields'且不在'Meta.exclude'中的字段 :return: """ meta_class = getattr(cls, "_meta") model = meta_class.model fields = meta_class.fields exclude = meta_class.exclude if fields is None and exclude is None: raise ImproperlyConfigured( "Creating a FilterSet without either the 'fields' attribute " "or the 'exclude' attribute is prohibited; filter %s " "needs updating." % cls.__name__ ) # 无字段设置排除意味着所有其他字段. if exclude is not None and fields is None: fields = ALL_FIELDS if fields == ALL_FIELDS: fields = model._meta.sorted_field_names # 移除`Meta.exclude`中的字段 exclude = exclude or [] if not isinstance(fields, dict): fields = [(f, ['exact']) for f in fields if f not in exclude] else: fields = [(f, lookups) for f, lookups in fields.items() if f not in exclude] return OrderedDict(fields)
def construct_ordering(self, ordering, queryset): query_model_fields = self.get_query_model_fields(queryset) norm_order_by = [] query_model_name = queryset.model_class.__name__ for item in ordering: if isinstance(item, models.Field): prefix = '-' if item._ordering.lower() == 'desc' else '' if query_model_name == item.model_class.__name__: item = "{prefix}{field_name}".format(prefix=prefix, field_name=item.name) else: item = "{prefix}{model_name}.{field_name}".format( prefix=prefix, model_name=item.model_class._meta.name, field_name=item.name) prefix = "-" if "-" in item else "+" field_name = item.lstrip(prefix) field = query_model_fields.get(field_name, None) if field is None: error_msg = "排序字段{field_name}无法在queryset.model_class或queryset.join的model找到".format( field_name=field_name) raise ImproperlyConfigured(error_msg) norm_order_by.append( field.desc() if item.startswith('-') else field.asc()) return norm_order_by
def get_hashers(): hashers = [] for hasher_path in settings.PASSWORD_HASHERS: hasher = import_object(hasher_path)() if not getattr(hasher, 'algorithm'): raise ImproperlyConfigured( "hasher doesn't specify an algorithm name: %s" % hasher_path) hashers.append(hasher) return hashers
def databases(self): if self._databases is None: self._databases = settings.DATABASES if self._databases and DEFAULT_DB_ALIAS not in self._databases: raise ImproperlyConfigured("You must define a '%s' database" % DEFAULT_DB_ALIAS) return self._databases
def _create_cache(cache_config, **kwargs): try: params = cache_config params.update(kwargs) backend = params.get('BACKEND') location = params.get('LOCATION', '') backend_module = import_module(backend) except ImportError as e: raise ImproperlyConfigured("Could not find backend '%s': %s" % (backend, e)) return backend_module.CacheWrapper(location, params)
def get_parsers(): parsers = [] for parser_path in settings.PARSER_CLASSES: parser = import_object(parser_path)() if not getattr(parser, 'media_type'): raise ImproperlyConfigured( "parser没有定义media_type值: {parser_path}".format( parser_path=parser_path)) parsers.append(parser) return parsers
def load_backend(backend_name): """ 加载数据库连接处理块,如果不存在,则抛出异常 :param backend_name: :return: """ try: return import_module(backend_name) except ImportError as e_user: raise ImproperlyConfigured( "{backend_name} isn't an available database backend." "\nError was: {msg}".format(backend_name=backend_name, msg=e_user))
def filter(self, qs, value): if self.distinct: qs = qs.distinct() if not value or (value.start is None and value.stop is None): return qs if self.source is None: field_name = self.field_name else: field_name = self.source if isinstance(field_name, models.Field): field = field_name elif isinstance(field_name, str) and "." in field_name: join_fields = self.get_join_fields(qs) field = join_fields[field_name.lower()] else: field = getattr(qs.model_class, field_name) if field is None: error_msg = "字段{field_name}无法在queryset.model_class或queryset.join的model找到".format( field_name=field_name) raise ImproperlyConfigured(error_msg) expressions = None if value.start is not None and value.stop is not None: expressions = [ models.Expression( field, models.OP.BETWEEN, models.Clause(value.start, models.R('AND'), value.stop)) ] else: if value.start is not None: expressions = [ models.Expression(field, models.OP.GTE, value.start) ] if value.stop is not None: expressions = [ models.Expression(field, models.OP.LTE, value.stop) ] if expressions is None: return qs qs_expressions = reduce(operator.and_, expressions) qs = self.get_method(qs)(qs_expressions) return qs
def __getitem__(self, alias): try: return self._caches.caches[alias] except AttributeError: self._caches.caches = {} except KeyError: pass cache_configs = settings.CACHES if alias not in cache_configs: raise ImproperlyConfigured( "Could not find config for '%s' in settings.CACHES" % alias) cache_backend = _create_cache(cache_configs[alias]) self._caches.caches[alias] = cache_backend return cache_backend
def __new__(mcs, name, bases, attrs): new_class = super(ModelFormMetaclass, mcs).__new__(mcs, name, bases, attrs) if bases == (BaseModelForm, ): return new_class form_opts = new_class._meta = ModelFormOptions( getattr(new_class, 'Meta', None)) if form_opts.model: # If a model is defined, extract form fields from it. if form_opts.fields is None and form_opts.exclude is None: raise ImproperlyConfigured( "Creating a ModelForm without either the 'fields' attribute " "or the 'exclude' attribute is prohibited; form %s " "needs updating." % name) if isinstance(form_opts.fields, str) and form_opts.fields.lower() == ALL_FIELDS: form_opts.fields = None model_fields = fields_for_model( model=form_opts.model, fields=form_opts.fields, exclude=form_opts.exclude, extra_kwargs=form_opts.extra_kwargs) # make sure opts.fields doesn't specify an invalid field none_model_fields = [k for k, v in model_fields.items() if not v] missing_fields = (set(none_model_fields) - set(new_class.declared_fields.keys())) if missing_fields: message = 'Unknown field(s) (%s) specified for %s' message = message % ', '.join( missing_fields), form_opts.model.__name__ raise FieldError(message) model_form_fields = model_fields model_form_fields.update(new_class.declared_fields) else: model_form_fields = new_class.declared_fields new_class.base_fields = model_form_fields return new_class
def construct_search(self, query_model_fields, field_name): """ 根据搜索字段的配置,构建搜索匹配模式进行返回 :param query_model_fields: :param field_name: :return: """ lookup = self.lookup_prefixes.get(field_name[0]) if lookup: field_name = field_name[1:] else: lookup = (models.OP.ILIKE, '%%%s%%') field = query_model_fields.get(field_name.lower(), None) if field is None: error_msg = "搜索字段{field_name}无法在queryset.model_class或queryset.join的model找到".format( field_name=field_name) raise ImproperlyConfigured(error_msg) return field, lookup[0], lookup[1]
def __new__(mcs, name, bases, attrs): new_class = super(ModelSerializerMetaclass, mcs).__new__(mcs, name, bases, attrs) opts = new_class._meta = ModelSerializerOptions( getattr(new_class, 'Meta', None)) if opts.model: if opts.fields is None and opts.exclude is None: raise ImproperlyConfigured( "Creating a ModelSerializer without either the 'fields' attribute " "or the 'exclude' attribute is prohibited; ModelSerializer %s " "needs updating." % name) if isinstance(opts.fields, str) and opts.fields.lower() == ALL_FIELDS: opts.fields = None fields = fields_for_model(model=opts.model, fields=opts.fields, exclude=opts.exclude) none_model_fields = [k for k, v in fields.items() if not v] missing_fields = (set(none_model_fields) - set(new_class.declared_fields.keys())) if missing_fields: message = 'Unknown field(s) (%s) specified for %s' message = message % ', '.join( missing_fields), opts.model.__name__ raise FieldError(message) fields.update(new_class.declared_fields) else: fields = new_class.declared_fields new_class.base_fields = fields return new_class