def add_login_user_data(view, data):
"""
给数据添加上用户数据
对于字段，这里分：正向的关系字段，反向的关系字段
"""
if view.request.method.upper() in ['GET', 'OPTIONS', 'DELETE']:
return
if view.action not in ['create', 'update', 'partial_update']:
return
if not view.request.data:
return
# 这里兼容签名方式
if view.request.user.is_anonymous:
return
model_name, model = view.model_slug, view.model
# 第一部分，先检测模型中的字段是否有引用用户模型，如果有，则注入用户数据
user = get_user_model().objects.get(id=view.request.user.id)
insert_user = partial(insert_user_info,
user_id=user.id,
action=view.action)
auth_fields = insert_user(data, model)
relation_fields = meta.get_all_relation_fields(model)
if relation_fields:
for item in relation_fields:
if item.name not in data or item.name in auth_fields:
# 如果字段没有在 data 中或者字段名称和 auth_fields 相同，则不做任何处理
continue
value = data[item.name]
if meta.check_field_is_reverse(item):
# FIXME: 当前反向字段使用的是列表数据结构
if not value or not isinstance(value, list):
continue
for reverse_item in value:
insert_user(reverse_item, item.related_model)
else:
# 这里说明是正向字段
if item.many_to_many:
# 说明是多对多字段
if not value or not isinstance(value, list):
continue
for child_item in value:
insert_user(child_item, item.related_model)
else:
# 使用字典数据结构
if isinstance(value, dict):
insert_user(value, item.related_model)
return data
def translate_expand_fields(self, expand_fields):
"""转换展开字段"""
for out_index, item in enumerate(expand_fields):
field_list = item.split('.')
model = self.model
for index, value in enumerate(field_list):
field = model._meta.get_field(value)
if meta.check_field_is_reverse(field):
result = meta.get_relation_field_related_name(
field.related_model, field.remote_field.name)
if result:
field_list[index] = result[0]
if field.is_relation:
model = field.related_model
expand_fields[out_index] = '.'.join(field_list)
return expand_fields
def create_nested_serializer_class(model,
field_list,
exclude_fields=None,
action=None,
end_slug=None,
display_fields=None,
**kwargs):
"""构建嵌套序列化类
此方法仅仅为 multiple_create_serializer_class 方法服务
"""
field_nest = field_list
attrs = {}
for key, value in field_nest.items():
field = get_field(model, key)
many = field.many_to_many
if meta.check_field_is_reverse(field):
many = False if field.one_to_one else True
if not value:
attrs[key] = create_serializer_class(
field.related_model,
exclude_fields=exclude_fields,
action=action,
end_slug=end_slug,
display_fields=nested_display_fields(model, display_fields,
key),
)(many=many)
else:
attrs[key] = create_nested_serializer_class(
field.related_model,
value,
exclude_fields=exclude_fields,
action=action,
end_slug=end_slug,
display_fields=nested_display_fields(model, display_fields,
key),
)(many=many)
return create_serializer_class(
model,
exclude_fields=exclude_fields,
action=action,
end_slug=end_slug,
attrs=attrs,
display_fields=display_fields,
)
def multiple_create_serializer_class(
model,
expand_fields=None,
tree_structure=None,
exclude_fields=None,
action=None,
end_slug=None,
display_fields=None,
):
"""多重创建序列化类"""
attrs = {}
if expand_fields is None:
if display_fields is not None:
expand_fields = display_fields_to_expand_fields(display_fields)
else:
expand_fields = []
expand_dict = sort_expand_fields(expand_fields)
for key, value in expand_dict.items():
field = get_field(model, key)
# 如果是反向字段，则使用另外一种方式
many = field.many_to_many
if meta.check_field_is_reverse(field):
many = False if field.one_to_one else True
attrs[key] = create_nested_serializer_class(
field.related_model,
value,
exclude_fields=exclude_fields,
action=action,
end_slug=end_slug,
display_fields=nested_display_fields(model, display_fields,
key))(many=many)
return create_serializer_class(
model,
exclude_fields=exclude_fields,
tree_structure=tree_structure,
action=action,
end_slug=end_slug,
display_fields=display_fields,
attrs=attrs,
)
def insert_user_to_data(model, user, data):
"""插入用户到数据中"""
# 第一部分，先检测模型中的字段是否有引用用户模型，如果有，则注入用户数据
auth_user_field = None
# 检测模型中是否有字段引用了用户模型
has_user_field = meta.get_related_model_field(model, get_user_model())
if has_user_field:
field_name = get_gmeta_config_by_key(model, gmeta.GMETA_CLIENT_USER_FIELD)
if field_name:
auth_user_field = field_name
# 如果用户数据中没有传递用户的数据，则进行插入
if field_name not in data:
data[field_name] = user.id
relation_fields = meta.get_all_relation_fields(model)
if relation_fields:
for item in relation_fields:
if item.name not in data or item.name == auth_user_field:
# 如果字段没有在 data 中或者字段名称和 auth_user_field 相同，则不做任何处理
continue
value = data[item.name]
if meta.check_field_is_reverse(item):
# FIXME: 当前反向字段使用的是列表数据结构
if not value or not isinstance(value, list):
continue
has_user_field = meta.get_related_model_field(
item.related_model, get_user_model()
)
if has_user_field:
field_name = get_gmeta_config_by_key(
item.related_model, gmeta.GMETA_CLIENT_USER_FIELD
)
if field_name:
for reverse_item in value:
if isinstance(reverse_item, dict):
# 如果用户数据中没有传递用户的数据，则进行插入
if field_name not in reverse_item:
reverse_item[field_name] = user.id
else:
# 这里说明是正向字段
if item.many_to_many:
# 说明是多对多字段
if not value or not isinstance(value, list):
continue
has_user_field = meta.get_related_model_field(
item.related_model, get_user_model()
)
if has_user_field:
field_name = get_gmeta_config_by_key(
item.related_model, gmeta.GMETA_CLIENT_USER_FIELD
)
if field_name:
for child_item in value:
if isinstance(child_item, dict):
# 如果用户数据中没有传递用户的数据，则进行插入
if field_name not in child_item:
child_item[field_name] = user.id
else:
# 使用字典数据结构
if isinstance(value, dict):
has_user_field = meta.get_related_model_field(
item.related_model, get_user_model()
)
if has_user_field:
field_name = get_gmeta_config_by_key(
item.related_model, gmeta.GMETA_CLIENT_USER_FIELD
)
if field_name:
# 如果用户数据中没有传递用户的数据，则进行插入
if field_name not in value:
value[field_name] = user