def serialize(self):
ret = dict(account=serialize_instance(self.account),
user=serialize_instance(self.user),
state=self.state,
email_addresses=[serialize_instance(ea)
for ea in self.email_addresses])
if self.token:
ret['token'] = serialize_instance(self.token)
return ret
def create(self, validated_data):
# Extraindo os dados da criança e salvando via serializer
dados_data = validated_data.pop('dados')
dados_serializer = self.fields['dados']
dados = dados_serializer.create(dados_data)
# Relacionando os dados criados com a solicitacao
validated_data['dados_id'] = dados.pk
# Criando o protocolo da solicitacao
validated_data['protocolo'] = gerador_de_protocolo(dados.pk)
# Pegando DRE e DISTRITO da solicitacao
validated_data['distrito'], validated_data['dre'] = get_dre_distrito(
dados.cep_moradia)
# Gerando Agrupamento
validated_data['agrupamento'] = define_agrupamento(
dados_data['dt_nasc_crianca'])
# Criando e obtendo a solicitacao
solicitacao = super().create(validated_data)
# # email
if solicitacao.protocolo and len(dados.email_responsavel) > 1:
contexto = {
'para': dados.email_responsavel,
'solicitacao': serialize_instance(solicitacao),
# 'dados': serialize_instance(dados)
}
envia_confirmacao_cadastro.delay(**contexto)
return solicitacao
def test_serializer(self):
class SomeValue:
pass
some_value = SomeValue()
class SomeField(models.Field):
def get_prep_value(self, value):
return 'somevalue'
def from_db_value(self, value, expression, connection, context):
return some_value
class SomeModel(models.Model):
dt = models.DateTimeField()
t = models.TimeField()
d = models.DateField()
img1 = models.ImageField()
img2 = models.ImageField()
img3 = models.ImageField()
something = SomeField()
def method(self):
pass
instance = SomeModel(dt=datetime.now(),
d=date.today(),
something=some_value,
t=datetime.now().time())
content_file = ContentFile(b'%PDF')
content_file.name = 'foo.pdf'
instance.img1 = content_file
instance.img2 = 'foo.png'
# make sure serializer doesn't fail if a method is attached to
# the instance
instance.method = method
instance.nonfield = 'hello'
data = utils.serialize_instance(instance)
instance2 = utils.deserialize_instance(SomeModel, data)
self.assertEqual(getattr(instance, 'method', None), method)
self.assertEqual(getattr(instance2, 'method', None), None)
self.assertEqual(instance2.something, some_value)
self.assertEqual(instance2.img1.name, 'foo.pdf')
self.assertEqual(instance2.img2.name, 'foo.png')
self.assertEqual(instance2.img3.name, '')
self.assertEqual(instance.nonfield, instance2.nonfield)
self.assertEqual(instance.d, instance2.d)
self.assertEqual(instance.dt.date(), instance2.dt.date())
for t1, t2 in [(instance.t, instance2.t),
(instance.dt.time(), instance2.dt.time())]:
self.assertEqual(t1.hour, t2.hour)
self.assertEqual(t1.minute, t2.minute)
self.assertEqual(t1.second, t2.second)
# AssertionError: datetime.time(10, 6, 28, 705776)
# != datetime.time(10, 6, 28, 705000)
self.assertEqual(int(t1.microsecond / 1000),
int(t2.microsecond / 1000))
def test_serializer_binary_field(self):
class SomeBinaryModel(models.Model):
bb = models.BinaryField()
bb_empty = models.BinaryField()
instance = SomeBinaryModel(bb=b'some binary data')
serialized = utils.serialize_instance(instance)
deserialized = utils.deserialize_instance(SomeBinaryModel, serialized)
self.assertEqual(serialized['bb'], 'c29tZSBiaW5hcnkgZGF0YQ==')
self.assertEqual(serialized['bb_empty'], '')
self.assertEqual(deserialized.bb, b'some binary data')
self.assertEqual(deserialized.bb_empty, b'')
def serialize_instance(self, instance):
return serialize_instance(instance)
def test_serialize(self):
"""check we can serialize the user object for allauth, custom types can break it"""
result = serialize_instance(self.user)
self.assertTrue(
isinstance(result, dict),
)
