class BaseCourseEnrollmentModelSerializer(ModelSerializerWithCreatedField):
date = serializers.DateField(format=settings.DATE_FORMAT)
class PaidSerializer(serializers.Serializer):
date = serializers.DateField(required=True)
proof = serializers.FileField(required=False)
class DateSerializer(serializers.Serializer):
date_from = serializers.DateField(format='%d-%m-%Y')
date_to = serializers.DateField(format='%d-%m-%Y')
aggregate_by = serializers.ChoiceField(choices=ANALYTICS_TYPES, required=False)
class EmployeeSerializer(serializers.ModelSerializer):
first_name = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
last_name = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
nickname = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
nationality = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
department = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
company = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
social_security_id = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
telephone = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
image = serializers.PrimaryKeyRelatedField(queryset=S3Object.objects.all(),
required=False,
allow_null=True)
wage = serializers.DecimalField(required=False,
decimal_places=2,
max_digits=12,
allow_null=True)
pay_period = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
#attendances = AttendanceSerializer(many=True, required=False, read_only=True)
incentive_pay = serializers.DecimalField(required=False,
decimal_places=2,
max_digits=15,
allow_null=True)
shift = ShiftSerializer(required=False)
card_id = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
employment_date = serializers.DateField(required=False, allow_null=True)
class Meta:
model = Employee
fields = ('id', 'name', 'first_name', 'last_name', 'nationality',
'wage', 'department', 'shift', 'pay_period', 'image',
'telephone', 'nickname', 'social_security_id',
'government_id', 'card_id', 'bank', 'account_number',
'company', 'incentive_pay', 'status', 'payment_option',
'manager_stipend', 'title', 'location', 'employment_date')
@staticmethod
def setup_eager_loading(cls, queryset):
""" Perform necessary eager loading of data. """
# select_related for "to-one" relationships
queryset = queryset.select_related('image', 'shift')
# prefetch_related for "to-many" relationships
queryset = queryset.prefetch_related('image', 'shift', 'equipments')
# Prefetch for subsets of relationships
queryset = queryset.prefetch_related(
Prefetch(
'unaffiliated_attendees',
queryset=Attendee.objects.filter(organization__isnull=True)))
return queryset
def create(self, validated_data):
"""Create a new instance of Employee
"""
shift = validated_data.pop('shift', None)
if shift:
shift = Shift.objects.get(pk=shift['id'])
try:
ed = timezone('Asia/Bangkok').normalize(
validated_data.pop('employment_date'))
except (AttributeError, KeyError) as e:
ed = None
logger.warn(e)
instance = self.Meta.model.objects.create(shift=shift,
employment_date=ed,
**validated_data)
return instance
def update(self, instance, validated_data):
shift_data = validated_data.pop('shift')
try:
ed = timezone('Asia/Bangkok').normalize(
validated_data.pop('employment_date'))
except (AttributeError, KeyError) as e:
ed = None
logger.info(e)
instance.employment_date = ed
instance.name = validated_data.pop('name', instance.name)
instance.title = validated_data.pop('title', instance.title)
instance.shift = Shift.objects.get(start_time=shift_data['start_time'],
end_time=shift_data['end_time'])
instance.pay_period = validated_data.pop('pay_period',
instance.pay_period)
instance.nationality = validated_data.pop('nationality',
instance.nationality)
instance.telephone = validated_data.pop('telephone',
instance.telephone)
instance.department = validated_data.pop('department',
instance.department)
instance.card_id = validated_data.pop('card_id', instance.card_id)
instance.bank = validated_data.pop('bank', instance.bank)
instance.account_number = validated_data.pop('account_number',
instance.account_number)
instance.government_id = validated_data.pop('government_id',
instance.government_id)
instance.social_security_id = validated_data.pop(
'social_security_id', instance.social_security_id)
instance.company = validated_data.pop('company', instance.company)
instance.location = validated_data.pop('location', instance.location)
instance.status = validated_data.pop('status', instance.status)
instance.payment_option = validated_data.pop('payment_option',
instance.payment_option)
instance.wage = validated_data.pop('wage', 0)
instance.manager_stipend = validated_data.pop('manager_stipend', 0)
instance.incentive_pay = validated_data.pop('incentive_pay', 0)
instance.image = validated_data.pop('image', instance.image)
instance.save()
return instance
def to_representation(self, instance):
"""
Override the 'to_representation' method to allow integration of products into
output data
"""
ret = super(EmployeeSerializer, self).to_representation(instance)
try:
iam_credentials = self.context['request'].user.aws_credentials
key = iam_credentials.access_key_id
secret = iam_credentials.secret_access_key
except AttributeError as e:
pass
try:
ret['image'] = {
'id': instance.image.id,
'url': instance.image.generate_url()
}
except AttributeError:
pass
request = self.context['request']
start_date = request.query_params.get('start_date', None)
end_date = request.query_params.get('end_date', None)
if start_date and end_date:
start_date = parser.parse(start_date)
end_date = parser.parse(end_date)
attendances = instance.attendances.filter(date__gte=start_date,
date__lte=end_date)
regular_time = 0
overtime = 0
gross_wage = 0
net_wage = 0
reimbursements = 0
incentive_pay = 0
sunday_time = 0
sunday_overtime = 0
for a in attendances:
if a.start_time and a.end_time:
a.calculate_net_wage()
if a.is_sunday:
sunday_time += a.regular_time
sunday_overtime += a.overtime
else:
regular_time += a.regular_time
overtime += a.overtime
gross_wage += a.gross_wage
reimbursements += a.reimbursement
incentive_pay += a.incentive_pay
net_wage += a.net_wage
if instance.pay_period == 'monthly':
gross_wage = instance.wage / Decimal('2')
net_wage = gross_wage + reimbursements + incentive_pay
if start_date.day > 10 and start_date.day < 26:
net_wage += instance.manager_stipend
ret['regular_time'] = regular_time / Decimal('8')
ret['overtime'] = overtime
ret['sunday_time'] = sunday_time / Decimal('8')
ret['sunday_overtime'] = sunday_overtime / Decimal('8')
ret['gross_wage'] = gross_wage
ret['reimbursements'] = reimbursements
ret['total_incentive_pay'] = incentive_pay
ret['net_wage'] = net_wage
ret['equipments'] = [{
'brand': e.brand,
'description': e.description
} for e in instance.equipments.all()]
return ret
class CommitmentSerializer(serializers.ModelSerializer):
committedDate = serializers.DateField(format="%d/%m/%Y")
class Meta:
model = Commitment
fields = '__all__'
class UserSerializers(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
user_img = serializers.ImageField(
required=False,
max_length=100,
error_messages={"max_length": "名称长度不能超过100"})
user_name = serializers.CharField(max_length=32, required=True)
password = serializers.CharField(max_length=86,
required=False,
write_only=True)
login_power = serializers.IntegerField(default=1, required=False)
login_state = serializers.IntegerField(default=0, required=False)
user_authority = serializers.IntegerField(required=False)
mobile_phone = serializers.CharField(max_length=32, required=False)
email = serializers.CharField(max_length=32, required=False)
nick_name = serializers.CharField(max_length=32, required=False)
sex = serializers.IntegerField(default=1, required=False)
birthday = serializers.DateField(required=False)
login_time = serializers.DateTimeField(required=False)
register_time = serializers.DateTimeField(required=False)
last_login_time = serializers.DateTimeField(required=False)
login_count = serializers.IntegerField(required=False)
person_intro = serializers.CharField(required=False)
gmt_created = serializers.DateTimeField(required=False,
format='%Y-%m-%d %H:%M:%S')
gmt_modified = serializers.DateTimeField(required=False,
format='%Y-%m-%d %H:%M:%S')
remark = serializers.CharField(max_length=255, required=False)
class Meta:
model = User
# field = ("id", "user_name", "password", "nick_name", "gmt_created", "gmt_modified", "remark")
fields = '__all__' # 这个是将所有的字段都序列化
def create(self, validated_data):
user_authority = 0
if User.objects.count() == 0:
user_authority = 1
return User.objects.create(user_authority=user_authority,
**validated_data) # 调用Idc模型进行create操作
def update(self, instance, validated_data):
user = User.objects.get(user_name=validated_data['user_name'])
file = validated_data.get('user_img', '')
# 图片不为空，保存图片
if file != '':
try:
img_name = '{}{}'.format(uuid.uuid4().hex, '.jpg') # 生成文件名
folder_path = os.path.join(settings.BASE_DIR, 'media',
'user_img')
if not os.path.exists(folder_path):
os.mkdir(folder_path)
file_path = os.path.join(folder_path, img_name) # 图片路径
with open(file_path, 'wb') as f:
for c in file.chunks():
f.write(c)
user.user_img = 'user_img/' + img_name
except IOError as e:
print(e)
user.nick_name = validated_data.get('nick_name', user.nick_name)
user.sex = validated_data.get('sex', user.sex)
if validated_data.get('password'):
user.password = make_password(validated_data.get('password'))
user.birthday = validated_data.get('birthday', user.birthday)
user.mobile_phone = validated_data.get('mobile_phone',
user.mobile_phone)
user.save()
return user
class RemovalSerializer(serializers.Serializer):
date_removed__date = serializers.DateField()
removals = serializers.IntegerField()
class WorkPaymentsSerializer(BaseSerializerTeacher):
"""
Сериалайзер для следующих типов справок:
- Справка по форме 2-НДФЛ
- Справка о выплате (не выплате) единовременного пособия на рождение ребенка
- Справка о ежемесячных выплатах сотрудника, находящегося в отпуске по уходу за ребенком (декрет)
"""
request_period = serializers.IntegerField(min_value=2010,
max_value=2020,
required=False)
copies_number = serializers.IntegerField(min_value=1,
max_value=10,
required=False)
child_fio = serializers.CharField(max_length=300, required=False)
child_date = serializers.DateField(required=False)
WAYS_TO_GET = ((1, "на электронную почту"), (2, "получить в МФЦ/отделе"))
way_to_get = serializers.ChoiceField(choices=WAYS_TO_GET)
PLACES_TO_GET = (
(1, "МФЦ Большая Семёновская, д. 38, аудитория В107"),
(2, "МФЦ Прянишникова, д. 2А, аудитория 1311"),
(3, "МФЦ Павла Корчагина, д. 22, аудитория 213"),
(4, "МФЦ Автозаводская, д. 16, аудитория 2315"),
(5, "Отдел кадров"),
(6, "Бухгалтерия"),
)
place_to_get = serializers.ChoiceField(choices=PLACES_TO_GET,
required=False)
def validate(self, data):
"""
Проверка получения места справки
"""
if dict(RequestTeacher.REQUESTS).get(data["request_title"]) == 'Справка по форме 2-НДФЛ' and \
not data.get("copies_number", None):
raise serializers.ValidationError({
"copies_number":
"необходимо указать количество копий справки (число от 1 до 10)",
})
if dict(RequestTeacher.REQUESTS).get(data["request_title"]) == 'Справка по форме 2-НДФЛ' and \
not data.get("request_period", None):
raise serializers.ValidationError(
{"request_period": "необходимо указать период справки"})
if dict(RequestTeacher.REQUESTS).get(data["request_title"]) == \
'Справка о ежемесячных выплатах сотрудника, находящегося в отпуске по уходу за ребенком (декрет)' and \
not data.get("request_period", None):
raise serializers.ValidationError(
{"request_period": "необходимо указать период справки"})
if data['way_to_get'] == 2 and not data.get("place_to_get", None):
raise serializers.ValidationError(
{"place_to_get": "необходимо выбрать место получения справки"})
if dict(RequestTeacher.REQUESTS).get(data["request_title"]) == \
'Справка о выплате (не выплате) единовременного пособия на рождение ребенка' \
and not (data.get("child_fio", None) or data.get("child_date", None)):
raise serializers.ValidationError({
"child_fio":
"необходимо указать ФИО ребёнка",
"child_date":
"необходимо указать дату рождения ребёнка",
})
return data
def save(self, **kwargs):
super(WorkPaymentsSerializer, self).save()
if self.validated_data["way_to_get"] == 2 and self.validated_data.get(
"place_to_get"):
temp_way = f'в {dict(self.PLACES_TO_GET).get(self.validated_data["place_to_get"])}'
else:
temp_way = f'на почту: {self.validated_data["email"]}'
self.text += f'\nСпособ получения: {temp_way}'
if dict(RequestTeacher.REQUESTS).get(
self.validated_data["request_title"]
) == 'Справка по форме 2-НДФЛ':
self.text += f'\nКоличество копий: {self.validated_data["copies_number"]}'
RequestTeacher.objects.create(
user_uuid=self.user.id,
contacts=self.contacts,
request_title=self.validated_data['request_title'],
request_text=self.text,
responsible_unit=1,
)
class OrderSerializer(serializers.ModelSerializer):
"""Order DRF serializer"""
created_by = NestedRelatedField(Advisor, read_only=True)
modified_by = NestedRelatedField(Advisor, read_only=True)
company = NestedRelatedField(Company)
contact = NestedRelatedField(Contact)
primary_market = NestedRelatedField(Country)
sector = NestedRelatedField(Sector, required=False, allow_null=True)
uk_region = NestedRelatedField(UKRegion, required=False, allow_null=True)
service_types = NestedRelatedField(ServiceType, many=True, required=False)
description = serializers.CharField(allow_blank=True, required=False)
contacts_not_to_approach = serializers.CharField(allow_blank=True,
required=False)
further_info = serializers.CharField(allow_blank=True, required=False)
existing_agents = serializers.CharField(allow_blank=True, required=False)
delivery_date = serializers.DateField(required=False, allow_null=True)
billing_address_country = NestedRelatedField(Country,
required=False,
allow_null=True)
completed_by = NestedRelatedField(Advisor, read_only=True)
cancellation_reason = NestedRelatedField(CancellationReason,
read_only=True)
cancelled_by = NestedRelatedField(Advisor, read_only=True)
default_error_messages = {
'readonly':
ugettext_lazy('This field cannot be changed at this stage.'),
}
class Meta:
model = Order
fields = (
'id',
'reference',
'status',
'created_on',
'created_by',
'modified_on',
'modified_by',
'company',
'contact',
'primary_market',
'sector',
'uk_region',
'service_types',
'description',
'contacts_not_to_approach',
'contact_email',
'contact_phone',
'product_info',
'further_info',
'existing_agents',
'permission_to_approach_contacts',
'delivery_date',
'po_number',
'discount_value',
'vat_status',
'vat_number',
'vat_verified',
'net_cost',
'subtotal_cost',
'vat_cost',
'total_cost',
'billing_company_name',
'billing_contact_name',
'billing_email',
'billing_phone',
'billing_address_1',
'billing_address_2',
'billing_address_town',
'billing_address_county',
'billing_address_postcode',
'billing_address_country',
'archived_documents_url_path',
'paid_on',
'completed_by',
'completed_on',
'cancelled_by',
'cancelled_on',
'cancellation_reason',
)
read_only_fields = (
'id',
'reference',
'status',
'created_on',
'created_by',
'modified_on',
'modified_by',
'contact_email',
'contact_phone',
'product_info',
'permission_to_approach_contacts',
'discount_value',
'net_cost',
'subtotal_cost',
'vat_cost',
'total_cost',
'archived_documents_url_path',
'paid_on',
'completed_by',
'completed_on',
'cancelled_by',
'cancelled_on',
'cancellation_reason',
'billing_company_name',
'billing_contact_name',
'billing_email',
'billing_phone',
)
validators = (
# only some of the fields can be changed depending of the status
OrderEditableFieldsValidator(
{
OrderStatus.draft: {
*ORDER_FIELDS_INVOICE_RELATED,
'description',
'service_types',
'sector',
'uk_region',
'contacts_not_to_approach',
'contact',
'existing_agents',
'further_info',
'delivery_date',
},
OrderStatus.quote_awaiting_acceptance: {
*ORDER_FIELDS_INVOICE_RELATED,
'contact',
},
OrderStatus.quote_accepted: {
*ORDER_FIELDS_INVOICE_RELATED,
'contact',
},
OrderStatus.paid: {'contact'},
OrderStatus.complete: {}, # nothing can be changed
OrderStatus.cancelled: {}, # nothing can be changed
}, ),
# contact has to work at company
ContactWorksAtCompanyValidator(),
# validate billing address if edited
AddressValidator(
lazy=True,
fields_mapping={
'billing_address_1': {
'required': True
},
'billing_address_2': {
'required': False
},
'billing_address_town': {
'required': True
},
'billing_address_county': {
'required': False
},
'billing_address_postcode': {
'required': False
},
'billing_address_country': {
'required': True
},
},
),
)
def validate_service_types(self, service_types):
"""Validates that service types are not disabled."""
if self.instance:
created_on = self.instance.created_on
else:
created_on = now()
disabled_service_types = [
service_type.name for service_type in service_types
if service_type.was_disabled_on(created_on)
]
if disabled_service_types:
raise serializers.ValidationError(
f'"{", ".join(disabled_service_types)}" disabled.', )
return service_types
def validate_primary_market(self, country):
"""Validates that the primary market is not disabled."""
if self.instance:
created_on = self.instance.created_on
else:
created_on = now()
try:
market = Market.objects.get(pk=country)
except Market.DoesNotExist:
raise serializers.ValidationError(
f"The OMIS market for country '{country}' doesn't exist.", )
else:
if market.was_disabled_on(created_on):
raise serializers.ValidationError(f'"{country}" disabled.')
return country
def _reset_vat_fields_if_necessary(self, data):
"""If vat_status is set and != 'eu', vat_number and vat_verified are reset."""
data_combiner = DataCombiner(self.instance, data)
vat_status = data_combiner.get_value('vat_status')
if vat_status and vat_status != VATStatus.eu:
data['vat_number'] = ''
data['vat_verified'] = None
return data
def validate(self, data):
"""Add extra logic to the default DRF one."""
data = self._reset_vat_fields_if_necessary(data)
return data
def create(self, validated_data):
"""
Populate `uk_region` during the order creation if not otherwise specified.
"""
if 'uk_region' not in validated_data:
validated_data['uk_region'] = validated_data['company'].uk_region
return super().create(validated_data)
def update(self, instance, validated_data):
"""
Update invoice details if any of the invoice related fields has changed.
"""
with transaction.atomic():
instance = super().update(instance, validated_data)
# update invoice details if necessary
if (instance.status == OrderStatus.quote_accepted and
(ORDER_FIELDS_INVOICE_RELATED & validated_data.keys())):
instance.update_invoice_details()
return instance
class BugSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
program = ProgramSerializer()
bug_version = VersionSerializer()
reported_by = UserSerializer(required=False)
reported_date = serializers.DateField(required=False)
suggested_fix = serializers.CharField(required=False, allow_blank=True)
comments = serializers.CharField(required=False,
allow_null=True,
allow_blank=True)
functional_area = AreaSerializer(required=False, allow_null=True)
assigned_to = UserSerializer(required=False, allow_null=True)
resolution_version = VersionSerializer(required=False, allow_null=True)
def create(self, validated_data):
program_validated = validated_data.pop('program')
try:
program = Program.objects.get(id=program_validated['id'])
except ObjectDoesNotExist:
raise NotFound(detail={
'message': 'Program doesn\'t exist.',
'program': program_validated
})
version_validated = validated_data.pop('bug_version')
try:
version = Version.objects.get(id=version_validated['id'],
program=program)
except ObjectDoesNotExist:
raise NotFound(detail={
'message': 'Version doesn\'t exist.',
'version': version_validated
})
instance = Bug(program=program,
reported_by=self.context['request'].user,
bug_version=version,
**validated_data)
instance.save()
return instance
def update(self, instance, validated_data):
validated_data.pop('reported_by')
program_validated = validated_data.pop('program')
try:
program = Program.objects.get(id=program_validated['id'])
instance.program = program
except ObjectDoesNotExist:
raise NotFound(detail={
'message': 'Program doesn\'t exist.',
'program': program_validated
})
version_validated = validated_data.pop('bug_version')
try:
version = Version.objects.get(id=version_validated['id'],
program=program)
instance.bug_version = version
except ObjectDoesNotExist:
raise NotFound(detail={
'message': 'Version doesn\'t exist.',
'version': version_validated
})
# instance.update(**validated_data)
assigned_to_validated = validated_data.pop('assigned_to', None)
if assigned_to_validated is not None:
try:
assigned_to_instance = User.objects.get(
id=assigned_to_validated['id'])
instance.assigned_to = assigned_to_instance
except ObjectDoesNotExist:
raise NotFound(
detail={
'message': 'User doesn\'t exist.',
'user': assigned_to_validated
})
functional_area_validated = validated_data.pop('functional_area', None)
if functional_area_validated is not None:
try:
instance.functional_area = Area.objects.get(
id=functional_area_validated['id'])
except ObjectDoesNotExist:
raise NotFound(
detail={
'message': 'Area doesn\'t exist.',
'area': functional_area_validated
})
resolution_version_validated = validated_data.pop(
'resolution_version', None)
if resolution_version_validated is not None:
try:
instance.resolution_version = Version.objects.get(
id=resolution_version_validated['id'])
except ObjectDoesNotExist:
raise NotFound(
detail={
'message': 'Version doesn\'t exist.',
'version': resolution_version_validated
})
instance.save()
Bug.objects.filter(id=instance.id).update(**validated_data)
instance.refresh_from_db()
return instance
class Meta:
model = Bug
fields = '__all__'
class UsuarioRegistroSerializer(serializers.Serializer):
nombre = serializers.CharField(
min_length=2,
max_length=250,
error_messages={'blank': 'El campo Nombre no puede estar vacío.'})
apellidoPaterno = serializers.CharField(
min_length=2,
max_length=250,
error_messages={
'blank': 'El campo Apellido Paterno no puede estar vacío.'
})
apellidoMaterno = serializers.CharField(
min_length=2,
max_length=250,
error_messages={
'blank': 'El campo Apellido Materno no puede estar vacío.'
})
fechaNacimiento = serializers.DateField()
email = serializers.EmailField(
validators=[
UniqueValidator(
queryset=Usuario.objects.all(),
message=
'Este Correo Electrónico ya se encuentra registrado. Por favor, Ingrese otro.'
)
],
error_messages={
'blank': 'El campo Correo Electrónico no puede estar vacío.'
})
password = serializers.CharField(
min_length=8,
max_length=64,
error_messages={
'blank':
'El campo Contraseña no puede estar vacío.',
'min_length':
'La Contraseña es muy corta, asegúrese que tenga al menos 8 caracteres.'
})
password_confirmation = serializers.CharField(
min_length=8,
max_length=64,
error_messages={
'blank':
'El campo Confirmar Contraseña no puede estar vacío.',
'min_length':
'Asegúrese el campo Confirmar Contraseña tenga al menos 8 caracteres.'
})
def validate(self, data):
passwd = data['password']
passwd_conf = data['password_confirmation']
if passwd != passwd_conf:
raise serializers.ValidationError(
'Por favor, verifique las contraseñas. No coinciden.')
password_validation.validate_password(passwd)
return data
def create(self, data):
data.pop('password_confirmation')
usuario = Usuario.objects.create_user(**data)
return usuario
"""
class WorkOrderInvoiceThirdSectionUpdateSerializer(serializers.ModelSerializer
):
invoice_quote_days = serializers.IntegerField(
required=True,
write_only=True,
)
invoice_quote_date = serializers.DateField(
required=True,
write_only=True,
)
invoice_customers_approval = serializers.CharField(
required=True,
write_only=True,
)
line01_notes = serializers.CharField(
required=True,
write_only=True,
)
line02_notes = serializers.CharField(
required=False,
write_only=True,
allow_null=True,
)
payment_date = serializers.DateField(
required=True,
write_only=True,
)
is_cash = serializers.BooleanField(
required=False,
write_only=True,
)
is_cheque = serializers.BooleanField(
required=False,
write_only=True,
)
is_debit = serializers.BooleanField(
required=False,
write_only=True,
)
is_credit = serializers.BooleanField(
required=False,
write_only=True,
)
is_other = serializers.BooleanField(
required=False,
write_only=True,
)
client_signature = serializers.CharField(
required=True,
write_only=True,
)
associate_sign_date = serializers.DateField(
required=True,
write_only=True,
)
associate_signature = serializers.CharField(
required=True,
write_only=True,
)
class Meta:
model = WorkOrderInvoice
fields = ('invoice_quote_days', 'invoice_quote_date',
'invoice_customers_approval', 'line01_notes', 'line02_notes',
'payment_date', 'is_cash', 'is_cheque', 'is_debit',
'is_credit', 'is_other', 'client_signature',
'associate_sign_date', 'associate_signature')
def update(self, instance, validated_data):
"""
Override this function to include extra functionality.
"""
instance.invoice_quote_days = validated_data.get(
'invoice_quote_days', instance.invoice_quote_days)
instance.invoice_quote_date = validated_data.get(
'invoice_quote_date', instance.invoice_quote_date)
instance.invoice_customers_approval = validated_data.get(
'invoice_customers_approval', instance.invoice_customers_approval)
instance.line_01_notes = validated_data.get('line01_notes',
instance.line_01_notes)
instance.line_02_notes = validated_data.get('line02_notes',
instance.line_02_notes)
instance.payment_date = validated_data.get('payment_date',
instance.payment_date)
instance.is_cash = validated_data.get('is_cash', instance.is_cash)
instance.is_cheque = validated_data.get('is_cheque',
instance.is_cheque)
instance.is_debit = validated_data.get('is_debit', instance.is_debit)
instance.is_credit = validated_data.get('is_credit',
instance.is_credit)
instance.is_other = validated_data.get('is_other', instance.is_other)
instance.client_signature = validated_data.get(
'client_signature', instance.client_signature)
instance.associate_sign_date = validated_data.get(
'associate_sign_date', instance.associate_sign_date)
instance.associate_signature = validated_data.get(
'associate_signature', instance.associate_signature)
instance.revision_version += 1
instance.save()
logger.info("Updated third section.")
return instance
class StartDateEndDateSerializer(serializers.Serializer):
start_date = serializers.DateField(format="%Y-%m-%d")
end_date = serializers.DateField(format="%Y-%m-%d")
class DateRangeSerializer(serializers.Serializer):
start = serializers.DateField(source='start_date',
format=settings.DATE_FORMAT)
end = serializers.DateField(source='end_date', format=settings.DATE_FORMAT)
class ProfileSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(source='pk', read_only=True)
user_id = serializers.IntegerField(
source='user.id',
read_only=True) # now we have the user_id available in the front
username = serializers.CharField(source='user.username', read_only=True)
email = serializers.EmailField(source='user.email', read_only=True)
alias = serializers.CharField(allow_blank=True, required=False)
##
# using SerializerMethodField to calculate the count / length
number_of_followers = serializers.SerializerMethodField(
'get_number_of_followers', read_only=True)
number_of_following = serializers.SerializerMethodField(
'get_number_of_following', read_only=True)
following = serializers.SerializerMethodField('check_following',
read_only=True)
##
bio = serializers.CharField(allow_blank=True, required=False)
date_of_birth = serializers.DateField(required=True)
image_url = serializers.URLField(allow_blank=True, required=False)
background_image_url = serializers.URLField(allow_blank=True,
required=False)
date_joined = serializers.DateTimeField(read_only=True)
number_of_likes = serializers.SerializerMethodField('get_number_of_likes',
read_only=True)
number_of_tweets = serializers.SerializerMethodField(
'get_number_of_tweets', read_only=True)
number_of_tweets_and_replies = serializers.SerializerMethodField(
'get_number_of_tweets_and_replies', read_only=True)
number_of_media = serializers.SerializerMethodField('get_number_of_media',
read_only=True)
class Meta:
model = Profile
fields = (
'username',
'id',
'user_id',
'email',
'alias',
'bio',
'number_of_likes',
'number_of_tweets',
'number_of_tweets_and_replies',
'number_of_media',
'date_of_birth',
'image_url',
'background_image_url',
'date_joined',
'following',
'number_of_followers',
'number_of_following',
)
def get_number_of_followers(self, obj):
return len(obj.followers.all())
def get_number_of_following(self, obj):
return len(obj.user.following.all())
def get_number_of_likes(self, obj):
return len(obj.user.liked_tweets.all()) + len(
obj.user.liked_replies.all())
def get_number_of_tweets(self, obj):
return len(obj.user.tweets.all())
def get_number_of_tweets_and_replies(self, obj):
return len(obj.user.tweets.all()) + len(obj.user.user_replies.all())
def get_number_of_media(self, obj):
return len(obj.user.tweets.filter(media=True))
def check_following(self, obj):
try:
request = self.context.get('request', None)
user = request.user
except:
return False
if user in obj.followers.all():
return True
return False
class DataSerializer(serializers.Serializer):
data_inicial = serializers.DateField()
data_final = serializers.DateField()
class DisconnectionsDictSerializer(serializers.Serializer):
'''Dictionary'''
dc_date = serializers.DateField(help_text="Disconnection date: dd/MM/YY hh:mm")
duration = serializers.IntegerField(help_text="Expressed in minutes as integer.")
class AbstractSerializer(serializers.ModelSerializer):
tags = serializers.ReadOnlyField(source="tags_names")
date = serializers.DateField(format="%d/%m/%Y")
class Meta:
fields = "__all__"
class SalesReportData(serializers.Serializer):
firstDate = serializers.DateField()
secondDate = serializers.DateField()
class AvaluoSerializer(serializers.ModelSerializer):
# Cliente
cliente_id = serializers.PrimaryKeyRelatedField(
write_only=True, queryset=Cliente.objects.all(), source='cliente')
cliente = ClienteSerializer(read_only=True)
# Bien
bien_id = serializers.PrimaryKeyRelatedField(required=False,
write_only=True,
queryset=Bien.objects.all(),
source='tipo_bien')
tipo_bien = BienSerializer(read_only=True)
# Proposito
proposito_id = serializers.PrimaryKeyRelatedField(
required=False,
write_only=True,
queryset=Proposito.objects.all(),
source='proposito')
proposito = PropositoSerializer(read_only=True)
# Servicio
tipo_servicio_id = serializers.PrimaryKeyRelatedField(
required=False,
write_only=True,
queryset=Servicio.objects.all(),
source='tipo_servicio')
tipo_servicio = ServicioSerializer(read_only=True)
# Inmueble
tipo_inmueble_id = serializers.PrimaryKeyRelatedField(
required=False,
write_only=True,
queryset=Inmueble.objects.all(),
source='tipo_inmueble')
tipo_inmueble = InmuebleSerializer(read_only=True)
datos_cliente = DatosClienteSerializer()
mancomunado = MancomunadoSerializer()
descripcion_bienes = DescripcionBienSerializer(many=True, required=False)
fecha_asignacion = serializers.DateField(
format="%d-%m-%Y",
input_formats=['%d-%m-%Y', 'iso-8601'],
required=False)
fecha_compromiso = serializers.DateField(
format="%d-%m-%Y",
input_formats=['%d-%m-%Y', 'iso-8601'],
required=False)
fecha_solicitud_correo = serializers.DateField(
format="%d-%m-%Y",
input_formats=['%d-%m-%Y', 'iso-8601'],
required=False)
class Meta:
model = Avaluo
# Serialize all fields
exclude = ()
def create(self, validated_data):
datos_cliente_data = validated_data.pop('datos_cliente', None)
mancomunado_data = validated_data.pop('mancomunado', None)
descripcion_bien_data = validated_data.pop('descripcion_bienes', None)
avaluo = Avaluo.objects.create(**validated_data)
if datos_cliente_data:
DatosCliente.objects.create(avaluo=avaluo, **datos_cliente_data)
if mancomunado_data:
Mancomunado.objects.create(avaluo=avaluo, **mancomunado_data)
if descripcion_bien_data:
for descripcion_data in descripcion_bien_data:
DescripcionBien.objects.create(avaluo=avaluo,
**descripcion_data)
return avaluo
class VolunteerFreezeSerializer(serializers.ModelSerializer):
expiration_date = serializers.DateField(required=True)
class Meta:
model = VolunteerFreeze
fields = ['volunteer', 'expiration_date']
class OpenApplicationViewSerializer(PartiesSerializerMixin,
GenericApplicationViewSerializer):
goods_types = serializers.SerializerMethodField()
additional_documents = serializers.SerializerMethodField()
licence = serializers.SerializerMethodField()
proposed_return_date = serializers.DateField(required=False)
trade_control_activity = serializers.SerializerMethodField()
trade_control_product_categories = serializers.SerializerMethodField()
goodstype_category = serializers.SerializerMethodField()
class Meta:
model = OpenApplication
fields = (GenericApplicationViewSerializer.Meta.fields +
PartiesSerializerMixin.Meta.fields + (
"activity",
"usage",
"goods_types",
"additional_documents",
"is_military_end_use_controls",
"military_end_use_controls_ref",
"is_informed_wmd",
"informed_wmd_ref",
"is_suspected_wmd",
"suspected_wmd_ref",
"intended_end_use",
"licence",
"is_shipped_waybill_or_lading",
"non_waybill_or_lading_route_details",
"temp_export_details",
"is_temp_direct_control",
"temp_direct_control_details",
"proposed_return_date",
"trade_control_activity",
"trade_control_product_categories",
"goodstype_category",
"contains_firearm_goods",
))
def get_goods_types(self, application):
goods_types = application.goods_type.all().prefetch_related(
"countries", "countries__flags")
default_countries = list(
Country.objects.filter(
countries_on_application__application_id=application.id))
return GoodsTypeViewSerializer(goods_types,
default_countries=default_countries,
many=True).data
def get_goodstype_category(self, instance):
key = instance.goodstype_category
value = GoodsTypeCategory.get_text(key)
return {"key": key, "value": value}
def get_licence(self, instance):
licence = Licence.objects.filter(case=instance).first()
if licence:
return CaseLicenceViewSerializer(licence).data
def get_trade_control_activity(self, instance):
key = instance.trade_control_activity
value = (instance.trade_control_activity_other
if key == TradeControlActivity.OTHER else
TradeControlActivity.get_text(key))
return {"key": key, "value": value}
def get_trade_control_product_categories(self, instance):
trade_control_product_categories = (
sorted(instance.trade_control_product_categories)
if instance.trade_control_product_categories else [])
return [{
"key":
tc_product_category,
"value":
TradeControlProductCategory.get_text(tc_product_category)
} for tc_product_category in trade_control_product_categories]
class FundSummarySerializer(serializers.Serializer):
id = serializers.IntegerField()
date = serializers.DateField(format="%d/%m/%Y")
funds = SingleFundInvestSerializer(many=True)
class TestDetailGet(serializers.Serializer): date = serializers.DateField() type = serializers.IntegerField() full_marks = serializers.IntegerField() pass_marks = serializers.IntegerField()
class InvoiceSerializer(core_serializers.RestrictedSerializerMixin,
serializers.HyperlinkedModelSerializer):
price = serializers.DecimalField(max_digits=15, decimal_places=7)
tax = serializers.DecimalField(max_digits=15, decimal_places=7)
total = serializers.DecimalField(max_digits=15, decimal_places=7)
items = serializers.SerializerMethodField()
issuer_details = serializers.SerializerMethodField()
customer_details = serializers.SerializerMethodField()
due_date = serializers.DateField()
file = serializers.SerializerMethodField()
class Meta:
model = models.Invoice
fields = (
'url',
'uuid',
'number',
'customer',
'price',
'tax',
'total',
'state',
'year',
'month',
'issuer_details',
'invoice_date',
'due_date',
'customer',
'customer_details',
'items',
'file',
'backend_id',
)
extra_kwargs = {
'url': {
'lookup_field': 'uuid'
},
'customer': {
'lookup_field': 'uuid'
},
}
def get_issuer_details(self, invoice):
return settings.WALDUR_INVOICES['ISSUER_DETAILS']
def get_customer_details(self, invoice):
return {
'name': invoice.customer.name,
'address': invoice.customer.address,
'country': invoice.customer.country,
'country_name': invoice.customer.get_country_display(),
'email': invoice.customer.email,
'postal': invoice.customer.postal,
'phone_number': invoice.customer.phone_number,
'bank_name': invoice.customer.bank_name,
'bank_account': invoice.customer.bank_account,
}
def get_file(self, obj):
return reverse(
'invoice-pdf',
kwargs={'uuid': obj.uuid.hex},
request=self.context['request'],
)
def get_items(self, invoice):
resource_uuid = self.context['request'].GET.get('resource_uuid')
qs = invoice.items.all()
if resource_uuid:
if core_utils.is_uuid_like(resource_uuid):
qs = qs.filter(resource__uuid=resource_uuid)
else:
raise rf_exceptions.ValidationError(
'Passed resource_uuid is not UUID.')
qs = qs.order_by('project_name', 'name')
items = utils.filter_invoice_items(qs)
serializer = InvoiceItemSerializer(items,
many=True,
context=self.context)
return serializer.data
class PaimentSerializer(PaimentModeSerializer):
amount = serializers.FloatField(required=True)
currency = serializers.CharField(required=True)
date = serializers.DateField(required=True)
paiment_mode = serializers.CharField(required=True)
class CustomRegisterSerializer(serializers.Serializer):
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
username = serializers.CharField(max_length=128, required=True)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
first_name = serializers.CharField(max_length=255, required=False)
last_name = serializers.CharField(max_length=255, required=False)
date_of_birth = serializers.DateField(required=False)
address_1 = serializers.CharField(required=False)
address_2 = serializers.CharField(required=False)
post_code = serializers.CharField(max_length=255, required=False)
telephone = serializers.CharField(max_length=20, required=False)
picture = serializers.ImageField(required=False, max_length=5000)
# def validate_username(self, username):
# username = get_adapter().clean_username(username)
# return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
"""
Save extra fields or other information like files using this method
:param request:
:param user: User to be saved
:return:
"""
if request.FILES and request.FILES['picture']:
self.save_profile_picture(user, request.FILES['picture'])
if self.cleaned_data.get('date_of_birth'):
user.date_of_birth = self.cleaned_data.get('date_of_birth')
if self.cleaned_data.get('address_1'):
user.address_1 = self.cleaned_data.get('address_1')
if self.cleaned_data.get('address_2'):
user.address_2 = self.cleaned_data.get('address_2')
if self.cleaned_data.get('post_code'):
user.post_code = self.cleaned_data.get('post_code')
if self.cleaned_data.get('telephone'):
user.telephone = self.cleaned_data.get('telephone')
user.save()
def get_cleaned_data(self):
return {
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'username': self.validated_data.get('username', ''),
'first_name': self.validated_data.get('first_name', None),
'last_name': self.validated_data.get('last_name', None),
'date_of_birth': self.validated_data.get('date_of_birth', None),
'address_1': self.validated_data.get('address_1', None),
'address_2': self.validated_data.get('address_2', None),
'post_code': self.validated_data.get('post_code', None),
'telephone': self.validated_data.get('telephone', None),
'picture': self.validated_data.get('picture', None),
}
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
self.custom_signup(request, user)
email = setup_user_email(request, user, [])
return user
def save_profile_picture(self, user, picture):
user.picture = picture
user.save()
class PatientExportSerializer(serializers.ModelSerializer):
birth_date = serializers.DateField(label=_('Birth date'), )
class Meta:
model = Patient
fields = ('family_name', 'first_name', 'original_name', 'birth_date')
class FizikakanCreateSerializer(serializers.ModelSerializer):
հհ_id = serializers.IntegerField()
Ամսաթիվը = serializers.DateField()
Քաշը = serializers.IntegerField()
Հասակը = serializers.IntegerField()
ԿրծքավանդակիՇրջանագիծըՀանգիստ = serializers.IntegerField()
ԿրծքավանդակիՇրջանագիծըՇնչելիս = serializers.IntegerField()
ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս = serializers.IntegerField()
ՓորիՇրջագիծը = serializers.IntegerField()
Շնչաչափը = serializers.IntegerField()
ՁեռքիՈՒժաչափըԱջ = serializers.IntegerField()
ՁեռքիՈՒժաչափըՁախ = serializers.IntegerField()
class Meta:
model = Ֆիզիկական
fields = (
'հհ_id',
'Ամսաթիվը',
'Քաշը',
'Հասակը',
'ԿրծքավանդակիՇրջանագիծըՀանգիստ',
'ԿրծքավանդակիՇրջանագիծըՇնչելիս',
'ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս',
'ՓորիՇրջագիծը',
'Շնչաչափը',
'ՁեռքիՈՒժաչափըԱջ',
'ՁեռքիՈՒժաչափըՁախ',
)
def create(self, validated_data):
հհ_id = validated_data['հհ_id']
Ամսաթիվը = validated_data['Ամսաթիվը']
Քաշը = validated_data['Քաշը']
Հասակը = validated_data['Հասակը']
ԿրծքավանդակիՇրջանագիծըՀանգիստ = validated_data[
'ԿրծքավանդակիՇրջանագիծըՀանգիստ']
ԿրծքավանդակիՇրջանագիծըՇնչելիս = validated_data[
'ԿրծքավանդակիՇրջանագիծըՇնչելիս']
ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս = validated_data[
'ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս']
ՓորիՇրջագիծը = validated_data['ՓորիՇրջագիծը']
Շնչաչափը = validated_data['Շնչաչափը']
ՁեռքիՈՒժաչափըԱջ = validated_data['ՁեռքիՈՒժաչափըԱջ']
ՁեռքիՈՒժաչափըՁախ = validated_data['ՁեռքիՈՒժաչափըՁախ']
try:
հհ = Գրանցում.objects.get(pk=հհ_id)
except Գրանցում.DoesNotExist:
raise serializers.ValidationError(
'Այսպիսի հերթական համարով գրանցված զինծառայող գոյություն չունի, մուտքագրեք ճիշտ հ/հ'
)
ֆիզիկական = Ֆիզիկական(
հհ=հհ,
Ամսաթիվը=Ամսաթիվը,
Քաշը=Քաշը,
Հասակը=Հասակը,
ԿրծքավանդակիՇրջանագիծըՀանգիստ=ԿրծքավանդակիՇրջանագիծըՀանգիստ,
ԿրծքավանդակիՇրջանագիծըՇնչելիս=ԿրծքավանդակիՇրջանագիծըՇնչելիս,
ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս=ԿրծքավանդակիՇրջանագիծըԱրտաշնչելիս,
ՓորիՇրջագիծը=ՓորիՇրջագիծը,
Շնչաչափը=Շնչաչափը,
ՁեռքիՈՒժաչափըԱջ=ՁեռքիՈՒժաչափըԱջ,
ՁեռքիՈՒժաչափըՁախ=ՁեռքիՈՒժաչափըՁախ)
ֆիզիկական.save()
return ֆիզիկական
class DailyConcurrentUsageSerializer(Serializer):
"""Serialize a report of daily RHEL concurrency over time for the API."""
date = serializers.DateField(required=True)
maximum_counts = serializers.ReadOnlyField()
