def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
profile = instance.userprofile
picture = instance.userprofile.picture
p_info = model_meta.get_field_info(profile)
pic_info = model_meta.get_field_info(picture)
for attr, value in validated_data.items():
if attr == 'userprofile':
for attr2, value2 in value.items():
if attr2 == 'picture':
for attr3, value3 in value2.items():
setattr(picture, attr3, value3)
else:
setattr(profile, attr2, value2)
elif attr in info.relations and info.relations[attr].to_many:
field = getattr(instance, attr)
field.set(value)
else:
setattr(instance, attr, value)
instance.save()
picture.save()
profile.save()
return instance
def create(self, validated_data: Dict, *args: Any,
**kwargs: Any) -> Organization:
serializers.raise_errors_on_nested_writes("create", self,
validated_data)
organization, _, _ = Organization.objects.bootstrap(
self.context["request"].user, **validated_data)
return organization
def create(self, validated_data):
raise_errors_on_nested_writes('create', self, validated_data)
if self.user and self.user.id:
validated_data['user'] = self.user
try:
instance = Investment.objects.create(**validated_data)
except TypeError:
tb = traceback.format_exc()
msg = (
'Got a `TypeError` when calling `%s.objects.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.objects.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception was:\n %s' %
(
Investment.__name__,
Investment.__name__,
self.__class__.__name__,
tb
)
)
raise TypeError(msg)
return instance
def update(self, instance, validated_data):
# Assigns current user to the lastUpdatedBy attribute
validated_data['lastUpdatedBy'] = self.context['request'].user
serializers.raise_errors_on_nested_writes('update', self,
validated_data)
info = serializers.model_meta.get_field_info(instance)
old_instance = Customer.objects.get(pk=instance.id)
# Simply set each attribute on the instance, and then save it.
# Note that unlike `.create()` we don't need to treat many-to-many
# relationships as being a special case. During updates we already
# have an instance pk for the relationships to be associated with.
m2m_fields = []
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
m2m_fields.append((attr, value))
else:
setattr(instance, attr, value)
instance.save()
# This is done because editing the id creates another instance, NOT recommended
# for more complex models where customer is a foreign key to another table
if (old_instance.id != instance.id):
old_instance.delete()
# Note that many-to-many fields are set after updating instance.
# Setting m2m fields triggers signals which could potentially change
# updated instance and we do not want it to collide with .update()
for attr, value in m2m_fields:
field = getattr(instance, attr)
field.set(value)
return instance
def update(self, instance: Employee, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
# Simply set each attribute on the instance, and then save it.
# Note that unlike `.create()` we don't need to treat many-to-many
# relationships as being a special case. During updates we already
# have an instance pk for the relationships to be associated with.
m2m_fields = []
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
m2m_fields.append((attr, value))
else:
setattr(instance, attr, value)
# instance.title='工程师'
# setattr(instance,'title','工程师')
with transaction.atomic():
instance.save()
instance.salary.basesalary = validated_data.get('basesalary')
instance.salary.titlesalary = validated_data.get('titlesalary')
instance.salary.save()
# Note that many-to-many fields are set after updating instance.
# Setting m2m fields triggers signals which could potentially change
# updated instance and we do not want it to collide with .update()
for attr, value in m2m_fields:
field = getattr(instance, attr)
field.set(value)
return instance
def create(self, validated_data):
#raise Exception(validated_data)
serializers.raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass(**validated_data)
except TypeError as exc:
msg = (
'Got a `TypeError` when calling `%s.objects.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.objects.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception text was: %s.' %
(
ModelClass.__name__,
ModelClass.__name__,
self.__class__.__name__,
exc
)
)
raise TypeError(msg)
if many_to_many:
for field_name, value in many_to_many.items():
setattr(instance, field_name, value)
return instance
def update(self, instance, validated_data):
serializers.raise_errors_on_nested_writes('update',
self, validated_data)
provided_time = validated_data['provided_time']
weekday = validated_data['day_of_week']
try:
day = available[weekday]
except KeyError:
print("That's not a valid day.")
today = datetime.datetime.now(pytz.UTC)
schedule_date = next_weekday(today, day)
schedule_time = datetime.datetime.strptime(provided_time, '%H:%M')
hour = schedule_time.hour
minute = schedule_time.minute
final_time = schedule_date.replace(hour=hour, minute=minute,
second=0, microsecond=0)
local_tz = pytz.timezone(validated_data['user'].time_zone)
offset_amt = local_tz.utcoffset(datetime.datetime.now())
final_time -= offset_amt
validated_data['time'] = final_time
validated_data.pop('provided_time', None)
validated_data.pop('day_of_week', None)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
def create(self, validated_data):
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass._default_manager.create_user(
**validated_data)
except TypeError:
tb = traceback.format_exc()
msg = ('Got a `TypeError` when calling `%s.%s.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.%s.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception was:\n %s' %
(ModelClass.__name__, ModelClass._default_manager.name,
ModelClass.__name__, ModelClass._default_manager.name,
self.__class__.__name__, tb))
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
field = getattr(instance, field_name)
field.set(value)
return instance
def create(self, validated_data):
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass._default_manager.create_user(
**validated_data)
except TypeError:
tb = traceback.format_exc()
msg = ((ModelClass.__name__, ModelClass._default_manager.name,
ModelClass.__name__, ModelClass._default_manager.name,
self.__class__.__name__, tb))
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
field = getattr(instance, field_name)
field.set(value)
return instance
def update(self, instance, validated_data):
if validated_data["order_pay"] == 3:
# 待退款
time_obj = Time.objects.filter(
time_id=validated_data["order_timeid"].time_id).first()
time_obj.time_surplus += 1
time_obj.save()
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
m2m_fields = []
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
m2m_fields.append((attr, value))
else:
setattr(instance, attr, value)
instance.save()
for attr, value in m2m_fields:
field = getattr(instance, attr)
field.set(value)
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
password = validated_data.get('password')
print('hello')
if password:
instance.password = password
instance.user.set_password(password)
print('password', instance.password, 'user password', instance.user.password)
instance.user.save()
instance.save()
return instance
#
# password = validated_data.get('password')
# print('password ', password)
#
# for attr, value in validated_data.items():
# setattr(instance, attr, value)
#
# instance.save()
#
# if password:
# print('password111 ', password)
#
# instance.password = password
# instance.save()
#
# # instance.user.save()
#
# return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
if 'name' in validated_data:
model = Album
name = validated_data['name']
validated_data['slug'] = slug_generator(name, model)
from_zone = pytz.timezone(TIME_ZONE)
if not 'created_at' in validated_data:
validated_data['created_at'] = instance.created_at
else:
validated_data['created_at'] = validated_data[
'created_at'].astimezone(from_zone)
if not 'updated_at' in validated_data:
validated_data['updated_at'] = timezone.now()
else:
validated_data['updated_at'] = validated_data[
'updated_at'].astimezone(from_zone)
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
field = getattr(instance, attr)
field.set(value)
else:
setattr(instance, attr, value)
instance.save()
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
if validated_data.get('class_id_id'):
c = validated_data.pop('class_id_id')
cla = Class.objects.get(id=c)
print(c)
instance.class_id = cla
instance.class_id.save()
if validated_data.get('subject_id'):
s = validated_data.pop('subject_id')
sub = Subject.objects.get(id=s)
instance.subject = sub
instance.subject.save()
if validated_data.get('teacher_id'):
t = validated_data.pop('teacher_id')
teach = Teacher.objects.get(id=t)
instance.teacher = teach
instance.teacher.save()
if validated_data.get('quater_id'):
q = validated_data.pop('quater_id')
qua = Quater.objects.get(id=q)
instance.quater = qua
instance.quater.save()
start_d = validated_data.get('start_date')
instance.start_date = start_d
finish_d = validated_data.get('finish_date')
instance.finish_date = finish_d
d = validated_data.get('day')
instance.day = d
instance.save()
return instance
def create(self, validated_data):
"""Override of create method."""
"""
We have a bit of extra checking around this in order to provide
descriptive messages when something goes wrong, but this method is
essentially just:
return ExampleModel.objects.create(**validated_data)
If there are many to many fields present on the instance then they
cannot be set until the model is instantiated, in which case the
implementation is like so:
example_relationship = validated_data.pop('example_relationship')
instance = ExampleModel.objects.create(**validated_data)
instance.example_relationship = example_relationship
return instance
The default implementation also does not handle nested relationships.
If you want to support writable nested relationships you'll need
to write an explicit `.create()` method.
"""
raise_errors_on_nested_writes("create", self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
for request_tenant in schema_handler(
self.context["request"].tenant):
instance = ModelClass._default_manager.create(
**validated_data, tenant=request_tenant)
except TypeError:
tb = traceback.format_exc()
msg = ("Got a `TypeError` when calling `%s.%s.create()`. "
"This may be because you have a writable field on the "
"serializer class that is not a valid argument to "
"`%s.%s.create()`. You may need to make the field "
"read-only, or override the %s.create() method to handle "
"this correctly.\nOriginal exception was:\n %s" % (
ModelClass.__name__,
ModelClass._default_manager.name,
ModelClass.__name__,
ModelClass._default_manager.name,
self.__class__.__name__,
tb,
))
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
field = getattr(instance, field_name)
field.set(value)
return instance
def create(self, validated_data):
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
try:
user = ModelClass._default_manager.create_user(**validated_data)
except TypeError:
tb = traceback.format_exc()
msg = ('Got a `TypeError` when calling `%s.%s.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.%s.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception was:\n %s' %
(ModelClass.__name__, ModelClass._default_manager.name,
ModelClass.__name__, ModelClass._default_manager.name,
self.__class__.__name__, tb))
raise TypeError(msg)
token = Token.objects.create(user_id=user.id)
self.data.update({'Authorization': f'Token {token.key}'})
self._data.update({'Authorization': f'Token {token.key}'})
# self.validated_data.update({'Authorization': f'Token {token.key}'})
# self.initial_data.update({'Authorization': f'Token {token.key}'})
# self._validated_data.update({'Authorization': f'Token {token.key}'})
return user
def update(self, instance, validated_data):
serializers.raise_errors_on_nested_writes('update', self,
validated_data)
provided_time = validated_data['provided_time']
weekday = validated_data['day_of_week']
try:
day = available[weekday]
except KeyError:
print("That's not a valid day.")
today = datetime.datetime.now(pytz.UTC)
schedule_date = next_weekday(today, day)
schedule_time = datetime.datetime.strptime(provided_time, '%H:%M')
hour = schedule_time.hour
minute = schedule_time.minute
final_time = schedule_date.replace(hour=hour,
minute=minute,
second=0,
microsecond=0)
local_tz = pytz.timezone(validated_data['user'].time_zone)
offset_amt = local_tz.utcoffset(datetime.datetime.now())
final_time -= offset_amt
validated_data['time'] = final_time
validated_data.pop('provided_time', None)
validated_data.pop('day_of_week', None)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
def create(self, validated_data):
# To ensure caution, require nested_writes to be explicitly allowed
if not (hasattr(self.Meta, "nested_writes") and self.Meta.nested_writes):
raise_errors_on_nested_writes("create", self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
raise ValueError(
"Many to many fields must be explicitly handled", field_name
)
elif not relation_info.reverse and (field_name in validated_data):
if not isinstance(
validated_data[field_name], relation_info.related_model
):
# Trying to set a foreign key but do not have the object, only the key
validated_data[
relation_info.model_field.attname
] = validated_data.pop(field_name)
instance = ModelClass(**validated_data)
if hasattr(instance, "on_create") and callable(instance.on_create):
instance.on_create()
if not getattr(self, "parent", False):
instance.save()
return instance
def update(self, instance, validated_data):
print(instance, validated_data)
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
extra_fields, validated_data = retrieve_extra_fields(**validated_data)
m2m_fields = []
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
m2m_fields.append((attr, value))
else:
setattr(instance, attr, value)
for attr, value in extra_fields.items():
setattr(instance.more, attr, value)
instance.save()
instance.more.save()
for attr, value in m2m_fields:
field = getattr(instance, attr)
field.set(value)
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
request = self.context['request']
u = User.objects.get(id=request.user.id)
if u.employee.position.degree == 9:
status_code = validated_data.pop('status')
task = Task(**validated_data)
task.save()
employee_id = Employee.objects.get(id=request.user.id)
status = Status.objects.get(code=status_code)
t = Task_status.objects.create(status=status, task=task)
t.editer = employee_id
if status.code == 4:
instance.done_date = datetime.today().date()
print(datetime.today().date())
t.save()
instance.save()
for attr, value in validated_data.items():
setattr(instance, attr, value)
return instance
def test_nested_serializer_create_and_update(self):
class NonRelationalPersonDataSerializer(serializers.Serializer):
occupation = serializers.CharField()
class NonRelationalPersonSerializer(serializers.ModelSerializer):
data = NonRelationalPersonDataSerializer()
class Meta:
model = NonRelationalPersonModel
fields = ['data']
serializer = NonRelationalPersonSerializer(
data={'data': {
'occupation': 'developer'
}})
assert serializer.is_valid()
assert serializer.validated_data == {
'data': {
'occupation': 'developer'
}
}
raise_errors_on_nested_writes('create', serializer,
serializer.validated_data)
raise_errors_on_nested_writes('update', serializer,
serializer.validated_data)
def update(self, instance, validated_data):
"""
Default `.update()` method, but with overwritten friends' m2m assignment and return object annotation
:param instance:
:param validated_data:
:return:
"""
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
m2m_fields = []
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
m2m_fields.append((attr, value))
else:
setattr(instance, attr, value)
instance.save()
for attr, value in m2m_fields:
field = getattr(instance, attr)
if attr == 'friends':
field.set(value, through_defaults={'created_at': timezone.now()})
return self.context['view'].get_object()
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
active_plan_id = validated_data.pop('active_plan', None)
# Simply set each attribute on the instance, and then save it.
# Note that unlike `.create()` we don't need to treat many-to-many
# relationships as being a special case. During updates we already
# have an instance pk for the relationships to be associated with.
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
field = getattr(instance, attr)
field.set(value)
else:
setattr(instance, attr, value)
if active_plan_id:
active_plan_id = active_plan_id['id']
try :
plan = Plan.objects.get(pk=active_plan_id)
except:
raise PlanDoesNotExist()
setattr(instance, 'active_plan', plan)
instance.save()
return instance
def update(self, instance, validated_data):
"""
Override default update method to counteract race conditions.
(See https://github.com/encode/django-rest-framework/issues/5897)
:param instance:
:param validated_data:
:return:
"""
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
update_fields = []
for attr, value in validated_data.items():
update_fields.append(attr)
if attr in info.relations and info.relations[attr].to_many:
field = getattr(instance, attr)
field.set(value)
else:
setattr(instance, attr, value)
# if instance.variable_info and instance.epsilon \
# and instance.user_step == instance.DepositorSteps.STEP_0600_EPSILON_SET:
# instance.is_complete = True
# else:
# instance.is_complete = False
# This needs to be added to tell the save method to update the value.
update_fields.append('is_complete')
# Specifically for this model, we are overriding the update method with an explicit list of
# update_fields, so we need to set the updated field manually.
# All other models will be updated without this step due to the auto_now option from the parent class.
instance.updated = timezone.now()
instance.save(update_fields=update_fields)
return instance
def create(self, validated_data):
"""
We have a bit of extra checking around this in order to provide
descriptive messages when something goes wrong, but this method is
essentially just:
return ExampleModel.objects.create(**validated_data)
If there are many to many fields present on the instance then they
cannot be set until the model is instantiated, in which case the
implementation is like so:
example_relationship = validated_data.pop('example_relationship')
instance = ExampleModel.objects.create(**validated_data)
instance.example_relationship = example_relationship
return instance
The default implementation also does not handle nested relationships.
If you want to support writable nested relationships you'll need
to write an explicit `.create()` method.
"""
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass.objects.create(**validated_data)
except TypeError as exc:
msg = (
'Got a `TypeError` when calling `%s.objects.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.objects.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception text was: %s.' %
(
ModelClass.__name__,
ModelClass.__name__,
self.__class__.__name__,
exc
)
)
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
setattr(instance, field_name, value)
return instance
def update(self, instance, validated_data):
serializers.raise_errors_on_nested_writes('update', self,
validated_data)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save(using=instance.appID)
return instance
def update(self, instance, validated_data):
if 'password' in validated_data:
serializers.raise_errors_on_nested_writes('update', self, validated_data)
instance.set_password(validated_data['password'])
instance.save()
return instance
else:
return super(DeviceOwnerSerializer, self).update(instance, validated_data)
def update(self, instance, validated_data):
serializers.raise_errors_on_nested_writes('update', self,
validated_data)
info = model_meta.get_field_info(instance)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save(using=instance.person.appID)
return instance
def create(self, validated_data: Dict[str, Any], **kwargs) -> Team:
serializers.raise_errors_on_nested_writes("create", self, validated_data)
request = self.context["request"]
organization = self.context["view"].organization # use the org we used to validate permissions
with transaction.atomic():
team = Team.objects.create_with_data(**validated_data, organization=organization)
request.user.current_team = team
request.user.save()
return team
def create(self, validated_data: Dict[str, Any]) -> Team:
serializers.raise_errors_on_nested_writes("create", self, validated_data)
request = self.context["request"]
with transaction.atomic():
validated_data.setdefault("completed_snippet_onboarding", True)
team = Team.objects.create_with_data(**validated_data, organization=request.user.organization)
request.user.current_team = team
request.user.save()
return team
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
for attr, value in validated_data.items():
if attr in self.UPDATE_AVAILABLE_FIELDS:
setattr(instance, attr, value)
instance.save()
return instance
def create(self, validated_data: Dict[str, Any], **kwargs) -> Team:
serializers.raise_errors_on_nested_writes("create", self, validated_data)
request = self.context["request"]
organization = request.user.organization
if organization is None:
raise exceptions.ValidationError("You need to belong to an organization first!")
with transaction.atomic():
team = Team.objects.create_with_data(**validated_data, organization=organization)
request.user.current_team = team
request.user.save()
return team
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
if 'password' in validated_data:
instance.set_password(validated_data.pop('password'))
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
def update(self, instance, validated_data):
serializers.raise_errors_on_nested_writes('update', self, validated_data)
# Simply set each attribute on the instance, and then save it.
# Note that unlike `.create()` we don't need to treat many-to-many
# relationships as being a special case. During updates we already
# have an instance pk for the relationships to be associated with.
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
if validated_data.get('class_id_id'):
p = validated_data.pop('class_id_id')
t = Class.objects.get(id=p)
instance.class_id = t
instance.class_id.save()
instance.save()
return instance
def build_obj(self, data=None):
""" Much of this is copied from the create method
of ModelSerializer in DRF, as we need to be able
to create an object using the serializer without saving it,
which the create method does not allow.
"""
from rest_framework.utils import model_meta
from rest_framework.serializers import raise_errors_on_nested_writes
# Copy as validated_data is mutated
if data == None:
data = self.validated_data
validated_data = copy.copy(data)
raise_errors_on_nested_writes('create', self, validated_data)
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass(**validated_data)
except TypeError as exc:
msg = (
'Got a `TypeError` when calling `%s.objects.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.objects.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception text was: %s.' %
(
ModelClass.__name__,
ModelClass.__name__,
self.__class__.__name__,
exc
)
)
raise TypeError(msg)
return instance
def update(self, instance, validated_data):
"""
Since anonymous users should be able to vote a post, they should only
be allowed to change the "votes" field, and to prevent users from
voting a post by 1000 up or down in one request we'll only change "votes"
by 1
"""
serializers.raise_errors_on_nested_writes('update', self, validated_data)
votes = validated_data.get('votes', self.instance.votes)
if votes > 0:
self.instance.votes += 1
elif votes < 0:
self.instance.votes -= 1
else:
self.instance.vote = self.instance.votes
instance.save()
return instance
def update(self, instance, validated_data):
user_updated.send(sender=self.__class__, instance=instance)
raise_errors_on_nested_writes('update', self, validated_data)
info = model_meta.get_field_info(instance)
# Simply set each attribute on the instance, and then save it.
# Note that unlike `.create()` we don't need to treat many-to-many
# relationships as being a special case. During updates we already
# have an instance pk for the relationships to be associated with.
for attr, value in validated_data.items():
if attr in info.relations and info.relations[attr].to_many:
field = getattr(instance, attr)
field.set(value)
else:
setattr(instance, attr, value)
instance.save()
return instance
def update(self, instance, validated_data):
raise_errors_on_nested_writes('update', self, validated_data)
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save(self.context.get('request').user)
return instance
