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())