class PaymentLineSerializer(EmbeddedDocumentSerializer):
total_amount = FloatField(required=False)
encasement_amount = FloatField(required=False)
paid_doc = BDynamicField(allow_null=True, required=False)
class Meta:
model = PaymentLine
fields = [
'encasement_amount', 'paid_doc', 'total_amount', 'remaining_amount'
]
class ProcedureSerializer(DocumentSerializer):
code = CharField()
name = CharField()
price = FloatField(required=False)
is_refundable = BooleanField(required=False)
NGAP_code = NGAPCodeSerializer(NGAPCode)
CCAM_code = CCAMCodeSerializer(CCAMCode)
modality = BReferenceField(serializer=ModalitySerializer, required=False)
tnr = FloatField(required=False)
class Meta:
model = Procedure
fields = ("id", "name", "code", "price", "is_refundable", "NGAP_code", "CCAM_code", "modality", "tnr")
class WorkstationConfigSerializer(ModelSerializer):
creator = SlugRelatedField(read_only=True, slug_field="username")
default_slab_render_method = CharField(
source="get_default_slab_render_method_display")
default_orientation = CharField(source="get_default_orientation_display")
default_slab_thickness_mm = FloatField()
window_presets = WindowPresetSerializer(many=True, read_only=True)
default_window_preset = WindowPresetSerializer()
default_overlay_lut = LookUpTableSerializer()
default_overlay_interpolation = CharField(
source="get_default_overlay_interpolation_display")
default_overlay_alpha = FloatField()
default_zoom_scale = FloatField()
class Meta:
model = WorkstationConfig
fields = [
"pk",
"slug",
"title",
"description",
"created",
"modified",
"creator",
"window_presets",
"default_window_preset",
"default_slab_thickness_mm",
"default_slab_render_method",
"default_orientation",
"default_overlay_alpha",
"default_overlay_lut",
"default_overlay_interpolation",
"overlay_segments",
"key_bindings",
"default_zoom_scale",
"show_image_info_plugin",
"show_display_plugin",
"show_invert_tool",
"show_flip_tool",
"show_window_level_tool",
"show_reset_tool",
]
swagger_schema_fields = swagger_schema_fields_for_charfield(
default_orientation=model._meta.get_field("default_orientation"),
default_slab_render_method=model._meta.get_field(
"default_slab_render_method"),
default_overlay_interpolation=model._meta.get_field(
"default_overlay_interpolation"),
)
class InvoicingDocumentSerializer(BillingDocumentSerializer):
beneficiary_name = CharField(read_only=True)
taxed_amount = FloatField(read_only=True)
text_amount = CharField(read_only=True)
remaining_amount = FloatField(read_only=True)
paid_amount = FloatField(read_only=True)
is_paid = BooleanField(read_only=True)
payment_status = CharField(read_only=True)
class Meta:
model = InvoicingDocument
fields = BillingDocumentSerializer.Meta.fields + [
'beneficiary_name', 'taxed_amount', 'text_amount',
'remaining_amount', 'paid_amount', 'is_paid', 'payment_status'
]
class ErrorReportingConfigSerializer(PassiveSerializer):
"""Config for error reporting"""
enabled = BooleanField(read_only=True)
environment = CharField(read_only=True)
send_pii = BooleanField(read_only=True)
traces_sample_rate = FloatField(read_only=True)
class BillableItemSerializer(Serializer):
type = ChoiceField([
'missed_reservation', 'tool_usage', 'area_access', 'consumable',
'staff_charge'
])
name = CharField(max_length=200, read_only=True)
details = CharField(max_length=500, read_only=True)
account = CharField(max_length=200, read_only=True)
account_id = IntegerField(read_only=True)
project = CharField(max_length=200, read_only=True)
project_id = IntegerField(read_only=True)
application = CharField(max_length=200, read_only=True)
username = CharField(max_length=200, read_only=True)
user_id = IntegerField(read_only=True)
start = DateTimeField(read_only=True)
end = DateTimeField(read_only=True)
quantity = FloatField(read_only=True)
def update(self, instance, validated_data):
pass
def create(self, validated_data):
pass
class Meta:
fields = '__all__'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for instance_type in instance_type_choices:
for score_type in score_types:
field_name = str(instance_type[0]).replace(
'-', '_') + '_' + str(score_type[0])
self.fields[field_name] = FloatField(read_only=True)
class UserProfileSerializerPrivate(UserProfileSerializer):
astrobin_index = FloatField(read_only=True,
source="get_scores.user_scores_index")
followers = IntegerField(read_only=True,
source="get_scores.user_scores_followers")
class Meta(UserProfileSerializer.Meta):
exclude = ()
class RpmReadingSerializer(ModelSerializer):
circumference = DecimalField(source="loom.circumference",
read_only=True,
decimal_places=3,
max_digits=12)
#tape_type foreignkey data
quality = CharField(source="loom.tape_type.quality.name", read_only=True)
denier = CharField(source="loom.tape_type.denier", read_only=True)
color = CharField(source="loom.tape_type.color", read_only=True)
#Bag_type foriegn key data
width = FloatField(source="loom.bag_type.width", read_only=True)
length = FloatField(source="loom.bag_type.length", read_only=True)
frame = CharField(source="loom.bag_type.frame", read_only=True)
color = CharField(source="loom.bag_type.color", read_only=True)
weight = FloatField(source="loom.bag_type.weight", read_only=True)
quantity = FloatField(source="loom.quantity", read_only=True)
date_time = DateTimeField(source="loom.date_time", read_only=True)
total = FloatField(read_only=True)
class Meta:
model = RpmReading
fields = (
"total",
"id",
"machine_no",
"rpm",
"time",
"meters",
"state",
"loom",
"circumference",
"quality",
"denier",
"color",
"width",
"length",
"frame",
"color",
"weight",
"quantity",
"date_time",
)
class FinancialAidRequestSerializer(serializers.Serializer):
"""
Serializer for financial aid requests
"""
original_income = FloatField(min_value=0)
original_currency = CharField()
program_id = IntegerField()
def validate(self, attrs):
"""
Validators for this serializer
"""
attrs["program"] = get_object_or_404(Program, pk=attrs["program_id"])
if not attrs["program"].financial_aid_availability:
raise ValidationError(
"Financial aid not available for this program.")
if not ProgramEnrollment.objects.filter(
program=attrs["program"],
user=self.context["request"].user).exists():
raise ValidationError("User not in program.")
if not is_profile_filled_out(self.context["request"].user.profile):
raise ValidationError("Profile is not complete")
return attrs
def save(self, **kwargs):
"""
Override save method
"""
try:
income_usd = determine_income_usd(
self.validated_data["original_income"],
self.validated_data["original_currency"])
except NotSupportedException:
raise ValidationError("Currency not supported")
user = self.context["request"].user
tier_program = determine_tier_program(self.validated_data["program"],
income_usd)
financial_aid = FinancialAid.objects.create(
original_income=self.validated_data["original_income"],
original_currency=self.validated_data["original_currency"],
tier_program=tier_program,
user=user,
income_usd=income_usd,
country_of_income=user.profile.country,
date_exchange_rate=now_in_utc(),
country_of_residence=user.profile.country,
)
if determine_auto_approval(financial_aid, tier_program) is True:
financial_aid.status = FinancialAidStatus.AUTO_APPROVED
else:
financial_aid.status = FinancialAidStatus.PENDING_DOCS
financial_aid.save_and_log(user)
return financial_aid
class DetailLineSerializer(EmbeddedDocumentSerializer):
code = CharField(required=False)
description = CharField(required=True)
discount = FloatField(default=0)
unit_price = FloatField(default=0)
qte = FloatField(default=0)
tariff = TariffSerializer(required=False, allow_null=True)
line_doc = BDynamicField()
is_comment = BooleanField(default=False)
total_amount = FloatField(read_only=True)
discount_amount = FloatField(read_only=True)
class Meta:
model = DetailLine
fields = [
'code', 'description', 'discount', 'unit_price', 'qte', 'tariff',
'line_doc', 'is_comment', 'total_amount', 'discount_amount'
]
class UserProfileSerializerPrivate(UserProfileSerializer):
astrobin_index = FloatField(read_only=True, source='get_scores.user_scores_index')
contribution_index = FloatField(read_only=True, source='get_scores.user_scores_contribution_index')
followers = IntegerField(read_only=True, source='get_scores.user_scores_followers')
locations = LocationSerializer(many=True, source='location_set')
def update(self, instance, validated_data):
locations = validated_data.pop('location_set', [])
instance = super(UserProfileSerializer, self).update(instance, validated_data)
instance.location_set.clear()
for location_data in locations:
location = Location.objects.get(pk=location_data.get('id'))
instance.location_set.add(location)
return instance
class Meta(UserProfileSerializer.Meta):
exclude = ()
class SubmitResultCombinedSerializer(serializers.Serializer):
# Result
match = serializers.IntegerField()
type = serializers.ChoiceField(choices=Result.TYPES)
replay_file = serializers.FileField(required=False)
game_steps = serializers.IntegerField()
submitted_by = serializers.HiddenField(
default=serializers.CurrentUserDefault())
arenaclient_log = FileField(required=False)
# Bot
bot1_data = FileField(required=False)
bot2_data = FileField(required=False)
# Participant
bot1_log = FileField(required=False)
bot2_log = FileField(required=False)
bot1_avg_step_time = FloatField(
required=False, validators=[validate_not_nan, validate_not_inf])
bot2_avg_step_time = FloatField(
required=False, validators=[validate_not_nan, validate_not_inf])
class MeasurementSerializer(serializers.ModelSerializer):
created = serializers.SerializerMethodField()
value = FloatField()
def get_created(self, ms):
# query is based on created on with time diff
return ms.created_localtime.strftime('%Y-%m-%d %H:%M:%S')
class Meta:
model = Measurement
fields = ('space', 'sensor', 'value', 'created')
class TouristOccupancySerializer(serializers.Serializer):
name_district = CharField()
name_neighborhood = CharField()
accommodation_type = CharField()
price = FloatField()
availability = IntegerField()
class Meta:
model = Resource
fields = ('name_district', 'name_neighborhood', 'accommodation_type',
'price', 'availability')
class PaymentSerializer(BillingDocumentSerializer):
beneficiary_type = CharField(allow_blank=True, allow_null=True)
deadline = BDateField(allow_null=True, required=False)
payer = BDynamicField(allow_null=True, required=False)
payer_type = CharField(allow_blank=True, allow_null=True)
received_amount = FloatField(default=0)
payment_mode = PaymentModeSerializer(allow_null=True, required=False)
lines = BEmbeddedListField(serializer=PaymentLineSerializer,
allow_null=True,
required=False)
consumed_amount = FloatField(read_only=True)
remaining_amount = FloatField(read_only=True)
payer_name = CharField(read_only=True)
beneficiary_name = CharField(read_only=True)
class Meta:
model = Payment
fields = BillingDocumentSerializer.Meta.fields + [
'beneficiary_type', 'deadline', 'payer', 'payer_type',
'received_amount', 'payment_mode', 'consumed_amount',
'remaining_amount', 'payer_name', 'beneficiary_name', 'lines'
]
class MeasurementSerializerPaginated(serializers.HyperlinkedModelSerializer):
created_on = serializers.SerializerMethodField()
time = serializers.SerializerMethodField()
value = FloatField()
def get_created_on(self, ms):
return ms.created_localtime.strftime('%Y-%m-%d %H:%M:%S')
def get_time(self, ms):
return ms.created_localtime.strftime('%H:%M')
class Meta:
model = Measurement
fields = ('value', 'created_on', 'time',)
class AverageRentalPriceSerializer(serializers.Serializer):
concept = CharField()
code_district = IntegerField()
name_district = CharField()
code_neighborhood = IntegerField()
name_neighborhood = CharField()
quarter = IntegerField()
price = FloatField()
year = IntegerField()
class Meta:
model = Resource
fields = ('concept', 'code_district', 'name_district',
'code_neighborhood', 'name_neighborhood', 'quarter', 'price',
'year')
class AverageResidentsSerializer(serializers.Serializer):
code_district = IntegerField()
name_district = CharField()
code_neighborhood = IntegerField()
name_neighborhood = CharField()
houses = IntegerField()
residents = IntegerField()
average_occupancy = FloatField()
year = IntegerField()
class Meta:
model = Resource
fields = ('code_district', 'name_district', 'code_neighborhood',
'name_neighborhood', 'houses', 'residents',
'average_occupancy', 'year')
class FinancialAidSerializer(serializers.Serializer):
"""
Serializer for Financial Aid objects
"""
original_income = FloatField(min_value=0)
original_currency = CharField()
program_id = IntegerField()
def validate(self, data):
"""
Validators for this serializer
"""
data["program"] = get_object_or_404(Program, pk=data["program_id"])
if not data["program"].financial_aid_availability:
raise ValidationError("Financial aid not available for this program.")
if not ProgramEnrollment.objects.filter(program=data["program"], user=self.context["request"].user).exists():
raise ValidationError("User not in program.")
return data
def save(self):
"""
Override save method
"""
if self.validated_data["original_currency"] != "USD":
raise ValidationError("Only USD supported currently")
user = self.context["request"].user
tier_program = determine_tier_program(self.validated_data["program"], self.validated_data["original_income"])
financial_aid = FinancialAid.objects.create(
original_income=self.validated_data["original_income"],
original_currency=self.validated_data["original_currency"],
tier_program=tier_program,
user=user,
income_usd=self.validated_data["original_income"],
country_of_income=user.profile.country,
date_exchange_rate=datetime.datetime.now()
)
if determine_auto_approval(financial_aid) is True:
financial_aid.status = FinancialAidStatus.AUTO_APPROVED
else:
financial_aid.status = FinancialAidStatus.PENDING_DOCS
financial_aid.save()
# Add auditing here
return financial_aid
class ProductSerializer(ModelSerializer):
is_on_sale = BooleanField(read_only=True)
current_price = FloatField(read_only=True)
description = CharField(min_length=2, max_length=200)
cart_items = OrderSerializer(many=True, read_only=True)
# price = FloatField(min_value=1.00, max_value=100000)
price = DecimalField(
min_value=1.00, max_value=100000,
max_digits=None, decimal_places=2,
)
sale_start = DateTimeField(
required=False,
input_formats=['%I:%M %p %d %B %Y'], format=None, allow_null=True,
help_text='Accepted format is "12:01 PM 16 April 2019"',
style={'input_type': 'text', 'placeholder': '12:01 AM 28 July 2019'},
)
sale_end = DateTimeField(
required=False,
input_formats=['%I:%M %p %d %B %Y'], format=None, allow_null=True,
help_text='Accepted format is "12:01 PM 16 April 2019"',
style={'input_type': 'text', 'placeholder': '12:01 AM 28 July 2019'},
)
photo = ImageField(default=None)
warranty = FileField(write_only=True, default=None)
class Meta:
model = Product
fields = (
'id', 'name', 'description', 'price', 'sale_start', 'sale_end',
'is_on_sale', 'current_price', 'cart_items',
'photo', 'warranty',
)
def update(self, instance, validated_data):
if validated_data.get('warranty', None):
instance.description += '\n\nWarranty Information:\n'
instance.description += b'; '.join(
validated_data['warranty'].readlines()
).decode('utf-8')
return super().update(instance, validated_data)
def create(self, validated_data):
validated_data.pop('warranty') # remove
return Product.objects.create(**validated_data)
class OrganizationSerializer(DocumentSerializer):
name = CharField(required=False, read_only=False, allow_null=True)
contact_full_name = CharField(required=False,
read_only=False,
allow_null=True)
default_refund_amount = FloatField(required=False, allow_null=True)
conventions = BEmbeddedListField(
serializer=OrganizationConventionSerializer,
required=False,
allow_null=True)
address = CharField(required=False, read_only=False, allow_null=True)
email = EmailField(required=False, allow_null=True)
phone_numbers = ListField(child=CharField(), required=False, default=[])
class Meta:
model = Organization
fields = [
"id", "name", "contact_full_name", "default_refund_amount",
"conventions", "address", "email", "phone_numbers"
]
class LocationField(_serializers.Serializer):
lat = FloatField(required=True)
lng = FloatField(required=True)
description = NameField(required=True)
JSONField(),
{
'type': 'object'
},
),
(
# FileField
FileField(),
{
'type': 'string',
'format': 'binary'
},
),
(
# FloatField
FloatField(),
{
'type': 'number'
},
),
(
# ImageField
ImageField(),
{
'type': 'string',
'format': 'binary'
},
),
(
# SlugField
SlugField(),
class ProductSerializer(
six.with_metaclass(DynamicFieldsDeclarativeMetaClass,
ModelSerializer)):
# FIXME category required during update
# FIXME check if same category
address = NestedAddressSerializer()
average_note = FloatField(read_only=True)
comment_count = IntegerField(read_only=True)
category = NestedCategorySerializer()
prices = NestedPriceSerializer(read_only=True, many=True)
pictures = NestedPictureSerializer(read_only=True, many=True)
owner = NestedUserSerializer()
slug = CharField(read_only=True, source='slug')
def _get_dynamic_fields(self):
fc = self._fields.copy()
if self.object:
props = self.object.fields_from_properties(TYPE_FIELD_MAP)
fc.update(props)
elif self.init_data:
# At this point, there is no category
# object yet, so it has to be retrieved.
# This is done the same way as in restore_fields
if self.init_data is not None and not isinstance(
self.init_data, dict):
self._errors['non_field_errors'] = ['Invalid data']
return None
data = {'category': self.init_data['category']}
reverted_data = {}
field = self._fields['category']
field.initialize(parent=self, field_name='category')
try:
field.field_from_native(data, None, 'category', reverted_data)
except ValidationError as err:
self._errors['category'] = list(err.messages)
return fc
props = reverted_data['category'].fields_from_properties(
TYPE_FIELD_MAP)
fc.update(props)
return fc
def _set_dynamic_fields(self, obj):
self._fields = obj
@property
def data(self):
if self.object:
self.object.annotate_with_property_values()
return super(ProductSerializer, self).data
def restore_object(self, attrs, instance=None):
# Set attributes with dynamic fields
instance = super(ProductSerializer,
self).restore_object(attrs, instance=instance)
existing = set()
properties = []
# Update or create property values from attributes
# Update existing PropertyValues
for prop_val in instance.properties.all():
prop_type = prop_val.property_type
existing.add(prop_type)
try:
prop_val.value = getattr(instance,
prop_type.prefixed_attr_name)
except AttributeError:
pass
properties.append(prop_val)
# Create added PropertyValues
for prop_type in instance.category.inherited_properties:
if prop_type not in existing:
try:
value = getattr(instance, prop_type.prefixed_attr_name)
except AttributeError:
continue
if value is not None:
properties.append(
PropertyValue(property_type=prop_type,
value=value,
product=instance))
# Set product.properties to updated properties
instance._related_data['properties'] = properties
return instance
def validate(self, attrs):
attrs = super(ProductSerializer, self).validate(attrs)
# update existing project
if self.object is not None:
old_category = self.object._get_category()
new_category = attrs.get('category', None)
ext_categories = set(PRODUCT_TYPE.values())
# If categories are belong to different trees, we have to check
# possibility to change category
if old_category.tree_id != new_category.tree_id:
if get_root_category(old_category) in ext_categories or \
get_root_category(new_category) in ext_categories:
raise serializers.ValidationError(
_(u'Vous ne pouvez pas modifier la catégorie'))
return attrs
def full_clean(self, instance):
instance = super(ProductSerializer, self).full_clean(instance)
if instance and instance.deposit_amount < 0:
self._errors.update(
{'deposit_amount': _(u'Value can\'t be negative')})
return None
return instance
def to_native(self, obj):
try:
obj.category = obj._get_category()
except AttributeError:
pass
return super(ProductSerializer, self).to_native(obj)
class Meta:
model = models.Product
fields = ('id', 'summary', 'deposit_amount', 'currency', 'description',
'address', 'average_note', 'prices', 'quantity',
'is_archived', 'category', 'owner', 'created_at',
'pro_agencies', 'comment_count', 'pictures', 'slug')
public_fields = ('id', 'summary', 'deposit_amount', 'currency',
'description', 'address', 'quantity', 'category',
'owner', 'comment_count', 'pro_agencies', 'prices',
'pictures', 'average_note', 'slug')
view_name = 'product-detail'
read_only_fields = ('is_archived', 'created_at')
immutable_fields = ('owner', )
class StatelessPortfolioItemSerializer(serializers.Serializer):
asset = IntegerField()
weight = FloatField()
volatility = FloatField()
class PortfolioStatelessSerializer(serializers.Serializer):
stdev = FloatField()
er = FloatField()
items = StatelessPortfolioItemSerializer(many=True)
class WorkstationConfigSerializer(ModelSerializer):
creator = SlugRelatedField(read_only=True, slug_field="username")
image_context = CharField(source="get_image_context_display",
read_only=True)
default_slab_render_method = CharField(
source="get_default_slab_render_method_display", read_only=True)
default_orientation = CharField(source="get_default_orientation_display",
read_only=True)
default_slab_thickness_mm = FloatField()
window_presets = WindowPresetSerializer(many=True, read_only=True)
default_window_preset = WindowPresetSerializer()
overlay_luts = LookUpTableSerializer(many=True, read_only=True)
default_overlay_lut = LookUpTableSerializer()
default_overlay_interpolation = CharField(
source="get_default_overlay_interpolation_display", read_only=True)
default_overlay_alpha = FloatField()
default_zoom_scale = FloatField()
enabled_preprocessors = SerializerMethodField()
class Meta:
model = WorkstationConfig
fields = [
"pk",
"slug",
"title",
"description",
"created",
"modified",
"creator",
"image_context",
"window_presets",
"default_window_preset",
"default_slab_thickness_mm",
"default_slab_render_method",
"default_orientation",
"default_overlay_alpha",
"overlay_luts",
"default_overlay_lut",
"default_overlay_interpolation",
"overlay_segments",
"key_bindings",
"default_zoom_scale",
"show_image_info_plugin",
"show_display_plugin",
"show_image_switcher_plugin",
"show_algorithm_output_plugin",
"show_overlay_plugin",
"show_invert_tool",
"show_flip_tool",
"show_window_level_tool",
"show_reset_tool",
"show_overlay_selection_tool",
"show_lut_selection_tool",
"enabled_preprocessors",
"auto_jump_center_of_gravity",
]
def get_enabled_preprocessors(self, obj):
if obj.enable_contrast_enhancement:
text = ["contrast_enhanced"]
else:
text = []
return text
class FloatRangeField(RangeField):
child = FloatField()
range_type = NumericRange
class StatisticsSerializer(serializers.Serializer):
std_dev = FloatField()
avg = FloatField()
cor = DictField(child=FloatField())
