class ExperienciaSerializer(serializers.ModelSerializer):
fecha_inicio = fields.DateField(input_formats=['%Y-%m-%dT%H:%M:%S.%fZ'])
fecha_fin = fields.DateField(input_formats=['%Y-%m-%dT%H:%M:%S.%fZ'])
class Meta:
model = Experiencia
fields = ['id', 'nombre', 'fecha_inicio', 'fecha_fin']
class ProyectoSerializerUpdate(serializers.HyperlinkedModelSerializer):
proyecto_fecha_inicio = fields.DateField(input_formats=['%Y-%m-%d'])
proyecto_fecha_finl = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = Proyecto
fields = ("proyecto_objetivo", "proyecto_alcance",
"proyecto_descripcion", "proyecto_presupuesto",
"proyecto_fecha_inicio", "proyecto_fecha_finl", "gerente")
class SubjectLocatorSerializer(serializers.ModelSerializer):
loc_date = fields.DateField(input_formats=['%Y-%m-%d'])
date_followup = fields.DateField(input_formats=['%Y-%m-%d'])
initial_call_date = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = SubjectLocator
fields = (
'subject_identifier',
'loc_admin',
'loc_date',
'first_name',
'last_name',
'initials',
'subject_cell',
'may_call',
'subject_cell_alt',
'subject_cell_alt_3',
'may_call_alt',
'subject_phone',
'may_call_tel',
'loc_email',
'may_contact_email',
'may_sms',
'loc_village',
'loc_address',
'may_visit_home',
'idcc_clinic',
'may_contact_idcc',
'loc_workplace',
'loc_workphone',
'may_contact_work',
'loc_kincontact',
'may_contact_kin',
'date_followup',
'initial_call_date',
'review_locator',
)
def create(self, validated_data):
"""
Create and return a new `SubjectLocator` instance, given the validated data.
"""
return SubjectLocator.objects.create(**validated_data)
def update(self, instance, validated_data):
"""
Update and return an existing `SubjectLocator` instance, given the validated data.
"""
subject_identifier = validated_data.get('subject_identifier',
instance.subject_identifier)
SubjectLocator.objects.filter(
subject_identifier=subject_identifier).update(**validated_data)
return instance
class SubsciptionSerializer(serializers.ModelSerializer):
"""
Serializer for Subscription model
"""
start_date = fields.DateField(input_formats=['%Y-%m-%d'])
expiry_date = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = models.Subscription
fields = '__all__'
class ProjectionSerializer(serializers.ModelSerializer):
date = fields.DateField(format='%d/%m/%Y')
start_time = fields.DateField(format='%H:%M')
end_time = fields.DateField(format='%H:%M')
room = RoomSerializer(many=False, read_only=True)
movie = MovieSerializer(many=False, read_only=True)
class Meta:
model = Projection
fields = '__all__'
class ProyectoSerializerInsert(serializers.HyperlinkedModelSerializer):
proyecto_fecha_inicio = fields.DateField(input_formats=['%Y-%m-%d'])
proyecto_fecha_finl = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = Proyecto
fields = ("proyecto_nombre", "proyecto_objetivo", "proyecto_alcance",
"proyecto_descripcion", "proyecto_presupuesto",
"proyecto_fecha_inicio", "proyecto_fecha_finl",
"proyecto_evaluacion_general", "proyecto_evaluacion")
def create(self, validated_data, gerente_usuario):
gerente = Gerente.objects.get(gerente_usuario=gerente_usuario)
validated_data['gerente'] = gerente
Proyecto.objects.create(**validated_data)
class CampaignSerializer(serializers.ModelSerializer):
start_date = fields.DateField(input_formats=["%Y-%m-%d"])
owner = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
class Meta:
model = Campaign
fields = "__all__"
class CardSerializer(serializers.ModelSerializer):
created_by = serializers.HiddenField(
default=serializers.CurrentUserDefault())
modified_by = serializers.HiddenField(
default=serializers.CurrentUserDefault())
due_date = fields.DateField(input_formats=['%Y-%m-%d'])
def create(self, validated_data):
users = validated_data['users']
card_obj = Card.objects.create(
title=validated_data['title'],
description=validated_data['description'],
due_date=validated_data['due_date'],
card_list=validated_data['card_list'],
status=validated_data['status'],
attachements=validated_data['attachements'],
created_by=validated_data['created_by'],
)
card_obj.save()
card_obj.save()
for user in users:
card_obj.users.add(user)
card_obj.save()
return card_obj
class Meta:
model = Card
fields = [
'title', 'description', 'modified_on', 'due_date', 'card_list',
'status', 'attachements', 'created_by', 'modified_by', 'users'
]
read_only_fields = ["created_by", "modified_by"]
class HorarioServicioSerializer(serializers.ModelSerializer):
fechaServicio = fields.DateField(input_formats=['%Y-%m-%d'])
horaInicio = fields.TimeField(input_formats=['%H:%M:%S'])
horaFin = fields.TimeField(input_formats=['%H:%M:%S'])
class Meta:
model = HorarioServicio
fields = '__all__'
def to_representation(self, instance):
representation = super(HorarioServicioSerializer,
self).to_representation(instance)
representation['bus'] = {
"idBus": instance.bus.idBus,
"modelo": instance.bus.modelo,
"patente": instance.bus.patente,
"capacidadPasajeros": instance.bus.capacidadPasajeros
}
representation['chofer'] = {
"idPersona": instance.chofer.idPersona,
"identificacionPais": instance.chofer.identificacionPais,
"nombrePrimario": instance.chofer.nombrePrimario,
"nombreSecundario": instance.chofer.nombreSecundario,
"apPaterno": instance.chofer.apPaterno,
"apMaterno": instance.chofer.apMaterno
}
representation['trayecto'] = {
"idTrayecto": instance.trayecto.idTrayecto,
"ciudadSalida": instance.trayecto.ciudadSalida,
"ciudadLlegada": instance.trayecto.ciudadLlegada
}
return representation
class inventorySerializer(serializers.ModelSerializer):
batch_date = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = Inventory
fields = '__all__'
class CustomUserSerializer(serializers.ModelSerializer):
"""
Currently unused in preference of the below.
"""
email = serializers.EmailField(required=True)
username = serializers.CharField(required=True)
password = serializers.CharField(min_length=8, write_only=True)
firstname = serializers.CharField(allow_blank=True)
lastname = serializers.CharField(allow_blank=True)
birthdate = fields.DateField(input_formats=['%Y-%m-%dT%H:%M:%S.%fZ'])
avatar = serializers.CharField(allow_blank=True)
mother_tongue = serializers.CharField(allow_blank=True)
country = serializers.CharField(allow_blank=True)
language = serializers.CharField(allow_blank=True)
class Meta:
model = NewUser
fields = ('email', 'username', 'password', 'birthdate', 'firstname',
'lastname', 'avatar', 'mother_tongue', 'country', 'language')
# fields = '__all__'
extra_kwargs = {'password': {'write_only': True}}
def create(self, validated_data):
password = validated_data.pop('password', None)
# as long as the fields are the same, we can just use this
instance = self.Meta.model(**validated_data)
if password is not None:
instance.set_password(password)
instance.save()
return instance
class RegistrationSerializer(serializers.ModelSerializer):
password2 = serializers.CharField(style={'input_type': 'password'},
write_only=True)
date = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = Account
fields = [
'email', 'phone', 'name', 'surname', 'gender', 'password',
'password2', 'date'
]
extra_kwargs = {'password': {'write_only': True}}
def save(self):
account = Account(
email=self.validated_data['email'],
phone=self.validated_data['phone'],
name=self.validated_data['name'],
surname=self.validated_data['surname'],
dob=self.validated_data['date'],
gender=self.validated_data['gender'],
)
password = self.validated_data['password']
password2 = self.validated_data['password2']
if int(account.phone) < 5000000000 or int(account.phone) > 5999999999:
raise serializers.ValidationError({"name": "Phone is not proper."})
if password != password2:
raise serializers.ValidationError(
{"password": "******"})
account.set_password(password)
account.save()
return account
class LotesSerializer(serializers.EmbeddedDocumentSerializer):
existencia = fields.IntegerField(required=True)
fecha_vencimiento = fields.DateField(required=False)
class Meta:
model = Lote
fields = "__all__"
class IssueGetSerializer(serializers.ModelSerializer):
dateCreate = fields.DateField(input_formats=['%d.%m.%Y'])
solutions = SolutionSerializer(many=True, read_only=True)
class Meta:
model = Issue
fields = "__all__"
class SolutionCreateSerializer(serializers.ModelSerializer):
pubDate = fields.DateField(input_formats=['%d.%m.%Y'])
class Meta:
model = Solution
fields = "__all__"
class PostSerializer(serializers.ModelSerializer):
"""Post モデルのシリアライザ
Postモデルの属性に加え、JOIN先のステータス名称と子モデルCommentの数を返す.
"""
status_name = serializers.CharField(source="status.name", read_only=True)
comment_cnt = serializers.SerializerMethodField("get_comment_count")
# ブラウザでテストするときは以下をコメントアウトする
cre_date = fields.DateField(input_formats=["%Y-%m-%dT%H:%M:%S.%fZ"])
class Meta:
model = models.Post
fields = (
"id",
"title",
"content",
"cre_date",
"status",
"status_name",
"username",
"comment_cnt",
)
# 子要素のコメントの数を取得して返却する
def get_comment_count(self, obj):
return models.Comment.objects.filter(post_id=obj.id).count()
def validate_cre_date(self, value):
if value < datetime.today().date():
raise serializers.ValidationError("作成日は当日以降を入力してください")
return value
def test_basic_mapping(self, assert_dict_equals):
"""
Confirm that the serializer can still handle models w/
standard Django fields
"""
class TestSerializer(DjongoModelSerializer):
class Meta:
model = GenericModel
fields = '__all__'
expected_dict = {
'id':
drf_fields.IntegerField(label='ID', read_only=True),
'big_int':
drf_fields.IntegerField(max_value=9223372036854775807,
min_value=-9223372036854775808),
'bool':
drf_fields.BooleanField(),
'char':
drf_fields.CharField(max_length=20),
'comma_int':
("CharField(validators=[<django.core.validators.RegexValidator "
"object>, <django.core.validators.MaxLengthValidator object>])"),
'date':
drf_fields.DateField(),
'date_time':
drf_fields.DateTimeField(),
'decimal':
drf_fields.DecimalField(decimal_places=5, max_digits=10),
'email':
drf_fields.EmailField(max_length=254),
'float':
drf_fields.FloatField(),
'integer':
drf_fields.IntegerField(max_value=2147483647,
min_value=-2147483648),
'null_bool':
drf_fields.NullBooleanField(required=False),
'pos_int':
drf_fields.IntegerField(max_value=2147483647, min_value=0),
'pos_small_int':
drf_fields.IntegerField(max_value=32767, min_value=0),
'slug':
drf_fields.SlugField(allow_unicode=False, max_length=50),
'small_int':
drf_fields.IntegerField(max_value=32767, min_value=-32768),
'text':
"CharField(style={'base_template': 'textarea.html'})",
'time':
drf_fields.TimeField(),
'url':
drf_fields.URLField(max_length=200),
'ip':
drf_fields.IPAddressField(),
'uuid':
"ModelField(model_field=<django.db.models.fields.UUIDField: uuid>)",
}
assert_dict_equals(TestSerializer().get_fields(), expected_dict)
def inner(value):
if isinstance(value, datetime.datetime):
f = rest_fields.DateTimeField()
return f.to_representation(value)
if isinstance(value, datetime.date):
f = rest_fields.DateField()
return f.to_representation(value)
raise ValueError("Invalid value: {}".format(value))
class CourseSerializer(serializers.ModelSerializer):
start_date = fields.DateField(required=False)
modules = ModuleSerializer(many=True, read_only=True)
teachers = TeacherSerializer(many=True, read_only=True)
students = StudentSerializer(many=True, read_only=True)
class Meta:
model = Course
fields = '__all__'
class UserCoursePlayedSerializer(serializers.ModelSerializer):
# course = CourseSerializer(read_only=True)
# user = UserSerializer()
time = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = UserCoursePlayed
fields = ('id', 'rating', 'score', 'time', 'course', 'user')
class Meta:
param_fields = (
('room_id', fields.IntegerField(label='会议室ID')),
('name', fields.CharField(label='名称', max_length=64)),
('description', fields.CharField(label='描述', max_length=255, required=False, default="")),
('date', fields.DateField(label='预定日期')),
('start_time', fields.TimeField(label='开始时间')),
('end_time', fields.TimeField(label='结束时间')),
)
class EntrySerializer(serializers.ModelSerializer):
tags = serializers.StringRelatedField(many=True)
lines = EntryLineSerializer(many=True)
event_date = fields.DateField(source='event.date')
event_name = fields.CharField(source='event.name')
event_state = fields.CharField(source='event.review_state')
class Meta:
model = Entry
fields = ('id', 'event', 'event_name', 'event_date', 'event_state',
'date', 'paraphrased', 'modified_date', 'tags', 'lines',
'note')
class BaseResultSerializer(Serializer):
id = fields.CharField()
type = fields.CharField()
source = fields.CharField()
title = fields.CharField()
#abstract = fields.CharField()
#summary = fields.CharField()
language = fields.CharField(required=False)
country = fields.CharField(required=False)
date = fields.DateField()
subjects = fields.ListField()
keywords = fields.ListField()
class ProfileSerializer(SerializerMixin, Serializer):
avatar = fields.ImageField(required=False)
birthdate = fields.DateField(required=False)
telephone = fields.CharField(required=False)
address = fields.CharField(required=False)
city = fields.CharField(required=False)
zip_code = fields.CharField(required=False)
def update(self, instance, validated_data):
# Check if the user has the permission
# to modify his user profile
if not instance.myuser.has_perm('accounts.change_myuserprofile'):
raise serializers.ValidationError('Permission denied', code='permission_denied')
return super().update(self.instance, validated_data)
class MilestoneSerializer(serializers.ModelSerializer):
date = fields.DateField(input_formats=['%Y-%m-%d'])
images = serializers.SerializerMethodField()
def get_images(self, obj):
images = MilestoneImage.objects.filter(milestone=obj)
return ImageSerializer(images, many=True, read_only=False).data
class Meta:
model = Milestone
fields = ('id', 'name', 'description', 'date', 'images')
def validate_date(self, value):
today = datetime.date.today() + datetime.timedelta(days=1)
if (value < today):
raise serializers.ValidationError(
"Date will be grater than today...")
return value
class AppointmentSerializer(serializers.ModelSerializer):
date = fields.DateField(input_formats=['iso-8601'])
class Meta:
model = Appointment
fields = ('id', 'date', 'time', 'patient_id', 'doctor_id')
#create the appointment instance
def create(self, validated_data):
obj = Appointment.objects.filter(
patient_id=validated_data["patient_id"],
doctor_id=validated_data["doctor_id"],
date=validated_data["date"])
if obj.exists():
raise serializers.ValidationError(
"already taken appoinment taken today")
obj = Appointment.objects.create(
patient_id=validated_data['patient_id'],
date=validated_data['date'],
time=validated_data['time'],
doctor_id=validated_data['doctor_id'])
return obj
class CreditCardSerializer(serializers.ModelSerializer):
"""
Credit Card serializer
"""
expiry_date = fields.DateField(input_formats=['%Y-%m-%d'])
class Meta:
model = models.CreditCard
exclude = ('cvv', 'user')
def is_valid(self):
valid = super(CreditCardSerializer, self).is_valid()
if not valid:
return valid
if self.validated_data["expiry_date"] < date.today():
raise serializers.ValidationError(
{"expiry_date": "The date cannot be in the past!"})
return True
def get_or_create(self):
return models.CreditCard.objects.get_or_create(
defaults=self.validated_data)
class EventSerializer(serializers.ModelSerializer):
"""Serializer class to transform JSON or list of JSON to django model.
Expected format produced from script:
```
{
"collection_id": String, max_length=50
"collection_title": String, max_length=1024
"action": Choice of ['added', 'updated', 'removed']
"datetime": ISO-8601 datetime format
}
```
"""
datetime = fields.DateField(input_formats=["%Y-%m-%d"])
class Meta:
model = Event
fields = [
"collection_id",
"collection_title",
"action",
"datetime",
]
def filter_last_contribution_date__lt(self, value):
# This query usually covers a lot of users, so inverting it makes it a lot faster.
date = fields.DateField().to_internal_value(value)
dt = datetime.combine(date, datetime.max.time())
return self._filter_by_users(~F(last_contribution_date__lt=dt), invert=True)
def filter_last_contribution_date__gt(self, value):
date = fields.DateField().to_internal_value(value)
dt = datetime.combine(date, datetime.max.time())
return self._filter_by_users(F(last_contribution_date__gt=dt))
