def group(self, request):
queryset = self.filter_queryset(self.get_queryset())
x_column = request.GET['_x_column']
x_lookup_name = request.GET.get('_x_lookup')
y_func = request.GET['_y_func'].lower()
y_column = request.GET.get('_y_column', 'id')
x_field = self.model._meta.get_field(x_column)
x_lookup = x_field.class_lookups.get(x_lookup_name)
y_field = self.model._meta.get_field(y_column)
if x_lookup:
x_field = x_lookup('none').output_field
x_serializer_class, x_serializer_kwargs = ModelSerializer().build_standard_field(x_column, x_field)
x_serializer = x_serializer_class(**x_serializer_kwargs)
y_serializer_class, y_serializer_kwargs = ModelSerializer().build_standard_field(y_column, y_field)
y_serializer = y_serializer_class(**y_serializer_kwargs)
queryset = GroupFilter().filter(queryset, {
'x_column': x_column,
'x_lookup': x_lookup,
'y_func': y_func,
'y_column': y_column
})
serializer = self.get_serializer(
queryset,
many=True,
group_serializer=x_serializer,
y_func_serializer=y_serializer
)
return Response(serializer.data)
def get_rest_field_from_model_field(model, model_field, **kwargs):
"""
通过model字段自动生成rest framework字段
"""
if isinstance(model_field, models.Field):
model_field = model_field.name
s = ModelSerializer()
info = model_meta.get_field_info(model)
for field_name, relation_info in info.forward_relations.items():
if relation_info.to_many:
continue
field = relation_info.model_field
target_field = field
verbose_name = [target_field.verbose_name]
help_text = [target_field.help_text]
while target_field.remote_field:
target_field = target_field.target_field
verbose_name.append(target_field.verbose_name)
help_text.append(target_field.help_text)
target_field = copy.deepcopy(target_field)
target_field.verbose_name = " - ".join(filter(lambda x: x, verbose_name))
target_field.help_text = " - ".join(filter(lambda x: x, help_text))
for attr in ('primary_key', 'blank', 'null', 'default', 'editable', 'serialize'):
if hasattr(field, attr):
setattr(target_field, attr, getattr(field, attr))
info.fields_and_pk[field.name] = target_field
try:
info.fields_and_pk[field.attname] = target_field
except AttributeError:
pass
field_info = info.fields_and_pk[model_field]
field_class, field_kwargs = s.build_field(model_field, info, model, 0)
field_kwargs.pop('read_only', None)
gen_validators = field_kwargs.pop('validators', None)
if gen_validators:
gen_validators = list(filter(
lambda x: not isinstance(x, (
validators.UniqueValidator, validators.BaseUniqueForValidator, ProhibitNullCharactersValidator
)),
gen_validators
))
if gen_validators:
field_kwargs['validators'] = gen_validators
field_kwargs = s.include_extra_kwargs(field_kwargs, kwargs)
if not field_kwargs.get('required') and 'default' not in field_kwargs:
field_kwargs['default'] = None if field_info.default is NOT_PROVIDED else field_info.default
if field_class is fields.BooleanField and field_kwargs['default'] is None:
field_class = fields.NullBooleanField
field_kwargs.pop('allow_null', None)
if not ('default' in kwargs or 'required' in kwargs or field_kwargs.get('required') or field_kwargs['default']):
if (not field_kwargs.get('allow_null', False) and field_kwargs['default'] is None) \
or (not field_kwargs.get('allow_blank', False) and not field_kwargs['default']):
field_kwargs['required'] = True
field_kwargs.pop('default')
return field_class(**field_kwargs)
def to_internal_value(self, data):
internal_value = ModelSerializer.to_internal_value(self, data)
field = internal_value['field']
field_type = field.field_type
typified_value_model = field_type.get_typified_value_model()
typified_value_serializer_class = (
TYPIFIED_VALUE_SERIALIZERS_CLASS_DICT.get(typified_value_model)
)
if not typified_value_serializer_class:
raise APIException(
'Serializer for {typified_value_model} is not defined'.format(
typified_value_model=typified_value_model
)
)
raw_value = data.get('value', None)
if not raw_value and not field.required:
return internal_value
typified_value_serializer = typified_value_serializer_class(data=data)
typified_value_serializer.fields['field'].queryset = (
self.fields['field'].get_queryset()
)
typified_value_serializer.fields['typified_value'].required = False
regex_pattern = field_type.regex_pattern
if regex_pattern:
regex_validator = RegexValidator(
regex=regex_pattern,
)
typified_value_field = (
typified_value_serializer.fields['typified_value']
)
typified_value_field.validators.append(regex_validator)
typified_value_serializer.is_valid(raise_exception=True)
return typified_value_serializer.validated_data
def update(self, instance, validated_data):
if not self.partial:
self._check_required_fields_availability(validated_data)
self._check_at_least_one_required_constraints(validated_data)
available_field_keys = self._get_available_field_keys(
validated_data)
application_type = instance.application_type
not_required_field_keys = application_type.field_set.filter(
required=False, ).values_list('key', flat=True)
missed_not_required_field_keys = (set(not_required_field_keys) -
set(available_field_keys))
instance.value_set.filter(
field__key__in=missed_not_required_field_keys).delete()
for value in validated_data['value_set']:
field = value['field']
if 'typified_value' not in value:
instance.value_set.filter(field=field).delete()
continue
try:
value_object = instance.value_set.get(field=field)
except Value.DoesNotExist:
value_object = Value(
field=field,
application=instance,
)
value_object.value = value['typified_value']
value_object.save()
validated_data_without_values = {
item_key: item_value
for (item_key, item_value) in validated_data.items()
if item_key != 'value_set'
}
return ModelSerializer.update(self, instance,
validated_data_without_values)
def to_internal_value(self, data):
internal_value = ModelSerializer.to_internal_value(self, data)
field = internal_value['field']
field_type = field.field_type
typified_value_model = field_type.get_typified_value_model()
typified_value_serializer_class = (
TYPIFIED_VALUE_SERIALIZERS_CLASS_DICT.get(typified_value_model))
if not typified_value_serializer_class:
raise APIException(
'Serializer for {typified_value_model} is not defined'.format(
typified_value_model=typified_value_model))
raw_value = data.get('value', None)
if not raw_value and not field.required:
return internal_value
typified_value_serializer = typified_value_serializer_class(data=data)
typified_value_serializer.fields['field'].queryset = (
self.fields['field'].get_queryset())
typified_value_serializer.fields['typified_value'].required = False
regex_pattern = field_type.regex_pattern
if regex_pattern:
regex_validator = RegexValidator(regex=regex_pattern, )
typified_value_field = (
typified_value_serializer.fields['typified_value'])
typified_value_field.validators.append(regex_validator)
typified_value_serializer.is_valid(raise_exception=True)
return typified_value_serializer.validated_data
def to_internal_value(self, data):
value_serializer = self.fields['values'].child
field = value_serializer.fields['field']
field.queryset = Field.objects.filter(
application_type__key=data.get('application_type'),
)
return ModelSerializer.to_internal_value(self, data)
def update(self, instance, validated_data):
print("========== CALLED UPDATE! ===========")
print(str(validated_data))
print(str(instance.id))
fields = ModelSerializer.get_fields(self)
info = model_meta.get_field_info(instance)
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
print("setting multiple " + str(instance) + " " + str(attr) + " " + str(value))
set_many(instance, attr, value)
else:
print("setting single " + str(instance) + " " + str(attr) + " " + str(value))
setattr(instance, attr, value)
instance.save()
print(fields)
return ModelSerializer.update(self, instance, validated_data)
def update(self, instance, validated_data):
instance = ModelSerializer.update(self, instance, validated_data)
instance.max_slices = EqualSequenceSlicer().get_max_slices(
instance.candies)
instance.is_valid_cake = CakeValidator().is_valid(instance)
instance.save()
return instance
def create(self, validated_data):
max_slices = EqualSequenceSlicer().get_max_slices(
validated_data['candies'])
validated_data['max_slices'] = max_slices
validated_data['is_valid_cake'] = CakeValidator().is_valid(
validated_data)
return ModelSerializer.create(self, validated_data)
def create(self, validated_data):
validated_data['student'] = self.context['request'].user.profile
validated_data['status'] = TicketStatus.pending.value
ticket = ModelSerializer.create(self, validated_data)
TicketEvent.objects.create(ticket=ticket,
event_type=TicketEventType.create.value,
user=ticket.student)
return ticket
def _get_serializers_to_check(
include_apps: Optional[Iterable[str]] = None,
) -> Tuple[Iterator[Type[Serializer]], Iterator[Type[ModelSerializer]]]:
serializer_classes = _filter_app_serializers(
_collect_serializers(s for s in Serializer.__subclasses__()
if s is not ModelSerializer # type: ignore
),
include_apps,
)
model_serializer_classes = _filter_app_serializers(
_collect_serializers(ModelSerializer.__subclasses__()), include_apps)
return (
serializer_classes,
cast(Iterator[Type[ModelSerializer]], model_serializer_classes),
)
def __init__(self, *args, **kwargs):
DefaultModelSerializer.__init__(self, *args, **kwargs)
# Cache the name of the primary key
self.pk = self.Meta.model._meta.pk.name.lower()
# Cache the natural key
if hasattr(self.Meta.model.objects, "get_by_natural_key"):
if self.Meta.model._meta.unique_together:
self.natural_key = self.Meta.model._meta.unique_together[0]
elif hasattr(self.Meta.model, "natural_key") and isinstance(
self.Meta.model.natural_key, tuple):
self.natural_key = self.Meta.model.natural_key
else:
self.natural_key = None
else:
self.natural_key = None
# Strip out the uniqueness validators on primary keys.
# We don't need them with our find-or-create feature.
for i in self.fields:
if i == self.pk or (self.natural_key and i in self.natural_key):
self.fields[i].required = False
if i == self.pk:
self.fields[i].validators = [
i for i in self.fields[i].validators
if not isinstance(i, UniqueValidator)
]
# Strip out the uniqueness validators on natural keys.
# We don't need them with our find-or-create feature.
self.validators = [
i for i in self.validators
if not isinstance(i, UniqueTogetherValidator)
or not i.fields == self.natural_key
]
def get_extra_kwargs(self):
"""
Filter out the 'company' field when the user is from management.
:return: A sequence with the extra field kwargs.
:rtype: tuple
"""
kwargs = ModelSerializer.get_extra_kwargs(self)
if not is_management(self.context["request"].user):
return kwargs
return {
**kwargs, "company": {
**kwargs.get("company", {}), "read_only": True
}
}
def save(self, **kwargs):
"""
Overridden to add the copy-query to the value.
The value and actual answer are copied in case that the answer
set (Answers) is changed. This way we can maintain the actual
value and delete the answer, or change it, safely and maintain
data integrity.
:param kwargs: The additional data to add to validated_data
:type kwargs: any
:return: The newly created 'Answered' instance
:rtype: activities.models.Answered
"""
return ModelSerializer.save(self, **kwargs, value=self.get_calc())
def update(self, instance, validated_data):
if not self.partial:
self._check_required_fields_availability(validated_data)
self._check_at_least_one_required_constraints(validated_data)
available_field_keys = self._get_available_field_keys(
validated_data
)
application_type = instance.application_type
not_required_field_keys = application_type.field_set.filter(
required=False,
).values_list(
'key',
flat=True
)
missed_not_required_field_keys = (
set(not_required_field_keys) - set(available_field_keys)
)
instance.value_set.filter(
field__key__in=missed_not_required_field_keys
).delete()
for value in validated_data['value_set']:
field = value['field']
if 'typified_value' not in value:
instance.value_set.filter(
field=field
).delete()
continue
try:
value_object = instance.value_set.get(field=field)
except Value.DoesNotExist:
value_object = Value(
field=field,
application=instance,
)
value_object.value = value['typified_value']
value_object.save()
validated_data_without_values = {
item_key: item_value
for (item_key, item_value)
in validated_data.items()
if item_key != 'value_set'
}
return ModelSerializer.update(
self,
instance,
validated_data_without_values
)
def get_field_names(self, declared_fields, info):
"""
Filter out the 'members' field when the user is a employee.
:param declared_fields: A mapping of the declared fields in order
:type declared_fields: collections.OrderedDict
:param info: Additional information about the current models fields
:type info: rest_framework.utils.model_meta.FieldInfo
:return: A sequence with the fields to serialize
:rtype: tuple
"""
fields = ModelSerializer.get_field_names(self, declared_fields, info)
if not is_employee(self.context["request"].user, False):
return fields
return tuple(field for field in fields if field != "members")
def post(self, request):
login_form = LoginForm(data=request.data)
context = {}
if login_form.is_valid():
auth_user = authenticate(mobile=request.data['mobile'],
password=request.data['password'])
if auth_user:
login(request, auth_user)
serialized_data = ModelSerializer(auth_user, many=True)
context = serialized_data
else:
context = {
'mistake': 'Username/Password is wrong'
}
else:
context = login_form.errors
return SimpleTemplateResponse('account/profile.html',
context)
def get_extra_kwargs(self):
"""
Overridden to hide the answerer for management or employer.
This is because a employee may never know who gave answers
except when the user created a reflection, but that's handled
within the ReflectionSerializer.
:return: The extra keyword arguments for the fields
:rtype: dict
"""
extra = ModelSerializer.get_extra_kwargs(self)
if is_employee(self.context.request.user):
current_arguments = extra.get(extra["answerer"], {})
extra["answerer"] = {**current_arguments, "write_only": False}
return extra
def update(self, instance, validated_data):
request = self.context.get("request")
if _only_admin(request):
errors = dict()
try:
_data = UserUpdateInput(**request.data)
has_email_update = self.update_email(_data, instance, errors)
has_username_update = self.update_username(
_data, instance, errors)
if len(errors.keys()) > 0:
raise ValidationError(detail=errors)
if has_email_update or has_username_update:
ActivityService.log(
UserActions.basic_info_updated,
model_instance=instance,
request=request,
)
except PydanticValidationError as e:
for error in e.errors():
errors[error.get("loc")[0]] = [error.get("msg")]
raise ValidationError(detail=errors)
# ignore if user is admin and attempting to update his groups and status
if request.user != instance:
self.update_groups(request, instance)
# update status
self.update_status(request, instance)
has_basic_info_changed = (
validated_data.get("first_name") != instance.first_name
or validated_data.get("last_name") != instance.last_name)
saved = ModelSerializer.update(self, instance, validated_data)
if has_basic_info_changed:
ActivityService.log(UserActions.basic_info_updated,
model_instance=instance,
request=request)
return saved
def convert_serializer_to_json(serializer: serializers.ModelSerializer):
try:
if not serializer.is_valid():
logger.error(
'UtilitySerializer convert_serializer_to_json Failed is_valid, error: {}'
.format(serializer.error_messages))
return None
return serializer.validated_data
# json_serialized_output = JSONRenderer().render(data=serializer.data)
#
# return json_serialized_output
# stream = io.BytesIO(json_serialized_output)
# json_conversion = JSONParser().parse(stream)
#return json_conversion
except Exception as ex:
return None
def save(self, **kwargs):
"""
Overridden to inform management after storing the data.
:param kwargs: The additional data to save
:type kwargs: any
:return: The newly created reflection instance
:rtype: activities.models.Reflection
"""
# XXX TODO: refactor to assigned management member of some sorts?
instance = ModelSerializer.save(self, **kwargs)
managers = User.objects.filter(groups=Groups.management)
context = self.get_context(instance)
company = instance.answerer.member.company
transport = MultiMailTransport(context, 3, company)
transport.finish(transport(manager.email, {}) for manager in managers)
return instance
def check_serializers(app_configs, **kwargs):
import inspect
from rest_framework.serializers import ModelSerializer
import conf.urls # noqa, force import of all serializers.
for serializer in ModelSerializer.__subclasses__():
# Skip third-party apps.
path = inspect.getfile(serializer)
if path.find("site-packages") > -1:
continue
if hasattr(serializer.Meta, "read_only_fields"):
continue
yield django.core.checks.Warning(
"ModelSerializer must define read_only_fields.",
hint="Set read_only_fields in ModelSerializer.Meta",
obj=serializer,
id="H300",
)
def aggregate(self, request):
queryset = self.filter_queryset(self.get_queryset())
y_func = request.GET['_y_func'].lower()
y_column = request.GET.get('_y_column', 'id')
y_field = self.model._meta.get_field(y_column)
y_serializer_class, y_serializer_kwargs = ModelSerializer().build_standard_field(y_column, y_field)
y_serializer = y_serializer_class(**y_serializer_kwargs)
queryset = AggregateFilter().filter(queryset, {
'y_func': y_func,
'y_column': y_column
})
serializer = self.get_serializer(
queryset,
y_func_serializer=y_serializer
)
return Response(serializer.data)
def check_serializers(app_configs, **kwargs):
"""
Custom checker for validating that all serializers have set read_only_fields.
If all fields are available for write, then read_only_fields should be an empty tuple.
Read_only serializers have a much better performance.
Source: https://hakibenita.com/django-rest-framework-slow
"""
import inspect
from rest_framework.serializers import ModelSerializer
import sys
# Sometimes devs have not set up their IDE when optimizing imports
# so the import could be accidentally removed, which will not import the serializers then.
# Hence, we check if the module has been imported.
if "tsg.urls" not in sys.modules:
raise ValueError(
"tsg.urls has not been imported! Likely it has been removed by your IDE when formatting the file?"
)
for serializer in ModelSerializer.__subclasses__():
# Skip third-party apps.
path = inspect.getfile(serializer)
if path.find("site-packages") > -1:
continue
if hasattr(serializer.Meta, "read_only_fields"):
continue
yield django.core.checks.Warning(
"ModelSerializer must define read_only_fields.",
hint="Set read_only_fields in ModelSerializer.Meta",
obj=serializer,
id="H300",
)
def update(self, instance, validated_data):
instance.edit_date = timezone.now()
instance.save()
return ModelSerializer.update(self, instance, validated_data)
def getColumn(self, serializer: serializers.ModelSerializer = None):
if not serializer:
serializer = self.get_serializer()
serializer_class = serializer.__class__
fields = serializer.get_fields()
show_fields = getattr(serializer_class.Meta, 'show_fields', set())
hide_fields = getattr(serializer_class.Meta, 'hide_fields', set())
search_fields = getattr(serializer_class.Meta, 'search_fields', set())
sortable_fields = getattr(serializer_class.Meta, 'sortable_fields',
set())
column = []
for prop in fields:
field = fields[prop]
field_type = field.__class__.__name__
info = {
'prop': prop,
'label': field.label or prop,
'hide': hide_fields == '__all__' or prop in hide_fields,
'search': search_fields == '__all__' or prop in search_fields,
'sortable': sortable_fields == '__all__'
or prop in sortable_fields,
'width': 'auto',
'align': 'left',
'overHidden': False,
}
type_info = self.FIELD_TYPE_MAP.get(field_type,
self.FIELD_TYPE_DEFAULT)
info.update(type_info)
allow_null = getattr(field, 'allow_null', False)
allow_blank = getattr(field, 'allow_blank', False)
allow_empty = getattr(field, 'allow_empty', False)
read_only = getattr(field, 'read_only', False)
write_only = getattr(field, 'write_only', False)
if not any([allow_null, allow_blank, allow_empty]):
rules = [{
'required': True,
'message': f"""请输入{info['label']}""",
'trigger': "blur"
}]
info['rules'] = rules
if read_only:
info['editDisabled'] = True,
info['clearable'] = False
if not isinstance(
field,
(ManyRelatedField, RelatedField, PrimaryKeyRelatedField)):
# 防止序列化该字段的关系模型所有数据
choices = getattr(field, 'choices', None)
if choices:
dicData = list(
map(
lambda choice: {
'value': choice[0],
'label': choice[1]
}, choices.items()))
info['dicData'] = dicData
info['type'] = 'select'
column.append(info)
return column
def get_field_names(self, declared_fields, info):
fields = ModelSerializer.get_field_names(self, declared_fields, info)
if 'application' in fields:
fields.remove('application')
return fields
def __init__(self, *args, **kwargs):
ModelSerializer.__init__(self, *args, **kwargs)
self.fields['typified_value'].source = 'value'
self.fields['typified_value'].field_name = 'value'
def to_internal_value(self, data):
value_serializer = self.fields['values'].child
field = value_serializer.fields['field']
field.queryset = Field.objects.filter(
application_type__key=data.get('application_type'), )
return ModelSerializer.to_internal_value(self, data)
def perform_create(self, serializer: ModelSerializer):
serializer.save(user=self.request.user)
def __init__(self, *args, **kwargs):
ModelSerializer.__init__(self, *args, **kwargs)
self.fields['typified_value'].source = 'value'
self.fields['typified_value'].field_name = 'value'
def get_field_names(self, declared_fields, info):
fields = ModelSerializer.get_field_names(self, declared_fields, info)
if 'application' in fields:
fields.remove('application')
return fields
