class RBACRuleSerializer(ConsulSerializer): """Serializer for RBACRule""" consul_model = RBACRule id = CustomUUIDField(default=generate_uuid) resource_endpoint = serializers.CharField() order = serializers.IntegerField(required=False) permissions = serializers.MultipleChoiceField(choices=RULE_PERMISSIONS) def validate(self, attrs): # Check the rule's order is not negative try: if attrs['order'] < 0: raise serializers.ValidationError({ 'detail': _("Invalid rule order %s for %s. The order " "must be a positive integer." % (attrs['order'], attrs['resource_endpoint'])) }) except KeyError: return attrs else: return attrs
class RegisterSerializer(serializers.Serializer): email = serializers.EmailField(required=True) username = serializers.CharField(required=False, write_only=True) organization = serializers.MultipleChoiceField( required=True, choices=sorted([(p.id, p.name) for p in OrganizationModel.objects.all()])) password1 = serializers.CharField(required=True, write_only=True) password2 = serializers.CharField(required=True, write_only=True) def validate(self, data): if data['password1'] != data['password2']: raise serializers.ValidationError( "The two password fields didn't match.") return data def create(self, validated_data): user = User(email=validated_data['email'], username=validated_data['username']) user.set_password(validated_data['password1']) user.save() orgs = OrganizationModel.objects.filter(pk__in=self.organization) user.profilemodel.organizations.add(orgs) user.save() return user
class UserSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) first_name = serializers.CharField(max_length=50) last_name = serializers.CharField(max_length=50) user_email = serializers.EmailField(max_length=50) user_age = serializers.IntegerField(default=0) user_password = serializers.CharField(max_length=20) user_gender = serializers.MultipleChoiceField(choices=GENDER) user_pitch = serializers.CharField(max_length=300) def create(self, validated_data): #Create and return new 'User' instance return User.objects.create(**validated_data) def update(self, instance, validated_data): #Update and return an existing 'User' instance instance.first_name = validated_data.get('first_name', instance.first_name) instance.last_name = validated_data.get('last_name', instance.last_name) instance.user_email = validated_data.get('user_email', instance.user_email) instance.user_age = validated_data.get('user_age', instance.user_age) instance.user_password = validated_data.get('user_password', instance.user_password) instance.user_gender = validated_data.get('user_gender', instance.user_gender) instance.user_pitch = validated_data.get('user_pitch', instance.user_pitch) instance.save() return instance
class BookingSerializer(serializers.Serializer): # Dates and time start_date = serializers.DateField(required=True) duration = serializers.DurationField(required=True) # Bikes and extras number_adult_bikes = serializers.ChoiceField( choices=[(number, '%s' % (number)) for number in range(1, 10)]) number_child_bikes = serializers.ChoiceField( choices=[(number, '%s' % (number)) for number in range(1, 3)]) number_extras = serializers.MultipleChoiceField( choices=BikeExtra.objects.all()) # Lunches number_veg_lunches = serializers.IntegerField( validators=[positive_integer]) number_meat_lunches = serializers.IntegerField( validators=[positive_integer]) number_fish_lunches = serializers.IntegerField( validators=[positive_integer]) # Guest info first_name = serializers.CharField(max_length=25) last_name = serializers.CharField(max_length=25) phone_number = serializers.CharField(max_length=25, required=False) email = serializers.EmailField() newsletter = serializers.BooleanField( default=True, help_text='Vill du ha nyheter och erbjudanden från oss?') # Extra message other = serializers.CharField(max_length=200)
class ShortCandidateProfileSerializer(serializers.ModelSerializer): job_type = serializers.MultipleChoiceField(choices=JOB_TYPE, allow_empty=False) technologies = TechnologySerializer(many=True, read_only=True) specialization = SpecializationSerializer(many=True, read_only=True) hourly_rate = HourlyRateSerializer(required=False, allow_null=True) monthly_rate = MonthlyRateSerializer(required=False, allow_null=True) hiring_date = serializers.SerializerMethodField(read_only=True) similar_candidates = serializers.SerializerMethodField( method_name='get_similar_candidates') class Meta: model = CandidateProfile fields = ("id", "job_type", "technologies", "hourly_rate", "monthly_rate", "hiring_date", "job_position", "cover_letter", "experience", "experience_level", "communication_languages", "is_identified", "created", "modified", "specialization", "country", "similar_candidates") def get_hiring_date(self, obj): user = self.context['request'].user if user.is_authenticated and user.user_type == 'COMPANY': try: candidate = user.company_profile.hired_candidates.filter( candidate=obj).first() return candidate.created except (ObjectDoesNotExist, AttributeError): return None def get_similar_candidates(self, obj): similar_positions = CandidateProfile.objects.filter( technologies__in=obj.technologies.all()).distinct().exclude( pk=obj.pk)[:3] return SimilarCandidateSerializer(similar_positions, many=True).data
class RoleSerializer(serializers.ModelSerializer): """Role Serializer""" permissions = serializers.MultipleChoiceField(choices=PERMISSION_CHOICES) body_detail = BodySerializerMin(read_only=True, source='body') users_detail = UserProfileSerializer(many=True, read_only=True, source='users') bodies = serializers.SerializerMethodField() class Meta: model = BodyRole fields = ('id', 'name', 'inheritable', 'body', 'body_detail', 'bodies', 'permissions', 'users', 'users_detail', 'priority', 'official_post') @classmethod def get_bodies(cls, obj): """Gets bodies including children if inheritable.""" if not obj.inheritable: return BodySerializerMin([obj.body], many=True).data return BodySerializerMin(cls.get_children_recursive(obj.body, []), many=True).data @classmethod def get_children_recursive(cls, body, children): """Returns an array including a body and its children.""" for child_body_relation in body.children.all(): cls.get_children_recursive(child_body_relation.child, children) if body not in children: children.append(body) return children
def test_against_partial_and_full_updates(self): field = serializers.MultipleChoiceField(choices=(('a', 'a'), ('b', 'b'))) field.partial = False assert field.get_value(QueryDict({})) == [] field.partial = True assert field.get_value(QueryDict({})) == rest_framework.fields.empty
class TestMultipleChoiceField(FieldValues): """ Valid and invalid values for `MultipleChoiceField`. """ valid_inputs = { (): set(), ('aircon', ): set(['aircon']), ('aircon', 'manual'): set(['aircon', 'manual']), } invalid_inputs = { 'abc': ['Expected a list of items but got type "str".'], ('aircon', 'incorrect'): ['"incorrect" is not a valid choice.'] } outputs = [(['aircon', 'manual', 'incorrect'], set(['aircon', 'manual', 'incorrect']))] field = serializers.MultipleChoiceField(choices=[ ('aircon', 'AirCon'), ('manual', 'Manual drive'), ('diesel', 'Diesel'), ]) def test_against_partial_and_full_updates(self): field = serializers.MultipleChoiceField(choices=(('a', 'a'), ('b', 'b'))) field.partial = False assert field.get_value(QueryDict({})) == [] field.partial = True assert field.get_value(QueryDict({})) == rest_framework.fields.empty
class OsqueryQuerySerializer(serializers.Serializer): PLATFORM_CHOICES = (('arch', 'Arch'), ('amazon', 'Amazon Linux'), # Red Hat based ('centos', 'CentOS'), # Red Hat based ('darwin', 'macOS'), ('debian', 'Debian'), # Debian based ('fedora', 'Fedora'), # Red Hat based ('freebsd', 'FreeBSD'), ('funtoo', 'Funtoo Linux'), # Gentoo based ('gentoo', 'Gentoo Linux'), # Gentoo based ('linux', 'Linux'), ('manjaro', 'Manjaro Linux'), ('oracle', 'Oracle Linux'), # Red Hat based ('redhat', 'Red Hat'), # TODO WHY? ('posix', 'POSIX'), # TODO WHY? ('rhel', 'Red Hat Enterprise Linux'), # Red Hat based ('scientific', 'Scientific Linux'), # Red Hat based ('ubuntu', 'Ubuntu'), # Debian based ('windows', 'Windows'), ) query = serializers.CharField() interval = serializers.IntegerField(min_value=10, max_value=2678400, default=3600) description = serializers.CharField(required=False, help_text="Description of what this query does. Not required") value = serializers.CharField(required=False, help_text="Why is this query relevant. Not required") removed = serializers.BooleanField(required=False, help_text='Include {"action": "removed"} results?') platform = serializers.MultipleChoiceField(choices=PLATFORM_CHOICES, required=False) shard = serializers.IntegerField(min_value=1, max_value=100, required=False, help_text="Restrict this query to a percentage (1-100) of target hosts") version = serializers.RegexField('^[0-9]+\.[0-9]+\.[0-9]+\Z', required=False, help_text="Only run on osquery versions greater than or equal-to *")
class BaseHookSerializer(serializers.HyperlinkedModelSerializer): event_types = serializers.MultipleChoiceField(choices=log.get_valid_events(), allow_blank=False) author_uuid = serializers.ReadOnlyField(source='user.uuid') hook_type = serializers.SerializerMethodField() class Meta(object): model = models.BaseHook fields = ( 'url', 'uuid', 'is_active', 'author_uuid', 'event_types', 'created', 'modified', 'hook_type' ) extra_kwargs = { 'url': {'lookup_field': 'uuid'}, } def create(self, validated_data): validated_data['user'] = self.context['request'].user return super(BaseHookSerializer, self).create(validated_data) def validate(self, validated_data): validated_data['event_types'] = list(validated_data['event_types']) return validated_data def get_hook_type(self, hook): raise NotImplemented
class TriggerRequestSerializer(serializers.Serializer): changed_before = serializers.DateTimeField(required=False) changed_after = serializers.DateTimeField(required=False) min_priority = serializers.ChoiceField( choices=models.Trigger.Priority.CHOICES, required=False) priority = serializers.MultipleChoiceField( choices=models.Trigger.Priority.CHOICES, required=False) acknowledge_status = serializers.ChoiceField( choices=models.Trigger.AcknowledgeStatus.CHOICES, required=False) host_name = serializers.CharField(required=False) host_id = serializers.CharField(required=False) # Value is not a good name for the filter, but let's keep consistency with Zabbix API. value = serializers.ChoiceField(choices=models.Trigger.Value.CHOICES, required=False) def validate(self, attrs): self._add_field_from_initial_data(attrs, 'include_events_count') self._add_field_from_initial_data(attrs, 'include_trigger_hosts') return attrs def _add_field_from_initial_data(self, attrs, name): param = self.initial_data.get(name) boolean_field = forms.NullBooleanField() try: param = boolean_field.to_python(param) except exceptions.ValidationError: param = None attrs[name] = param
class TopicInterestsSerializer(SBSerializer): interests = serializers.MultipleChoiceField( choices=settings.TOPICS_OF_INTEREST, allow_blank=True) def create(self, validated_data): from sb_tags.neo_models import Tag from sb_tags.serializers import TagSerializer request, _, _, _, _ = gather_request_data(self.context) generated_tags = [] if request is None: raise serializers.ValidationError( "Must perform creation from web request") for tag in validated_data['interests']: try: query = 'MATCH (profile:Pleb {username: "******"}), ' \ '(tag:Tag {name: "%s"}) ' \ 'CREATE UNIQUE (profile)-[:INTERESTED_IN]->(tag) ' \ 'RETURN tag' % (request.user.username, slugify(tag)) res, _ = db.cypher_query(query) generated_tags.append(TagSerializer(Tag.inflate(res.one)).data) except(ConstraintViolation, Exception): pass cache.delete(request.user.username) return generated_tags
class ShortAgencyProfileSerializer(serializers.ModelSerializer): technologies = TechnologySerializer(many=True, read_only=True) specialization = SpecializationSerializer(many=True, read_only=True) average_hourly_rate = AverageHourlyRateSerializer(read_only=True) communication_languages = serializers.MultipleChoiceField( choices=LANGUAGES, allow_empty=False) hiring_date = serializers.SerializerMethodField(read_only=True) class Meta: model = AgencyProfile fields = ("id", "company_name", "company_description", "average_hourly_rate", "specialization", "communication_languages", "technologies", "country", "number_of_specialists", "founded", "company_type", "hiring_date") def get_hiring_date(self, obj): user = self.context['request'].user if user.is_authenticated and user.user_type == 'COMPANY': try: agency = user.company_profile.hired_agencies.filter( agency=obj).first() return agency.created except (ObjectDoesNotExist, AttributeError): return None
class InventoryFilterSerializer(serializers.Serializer): meta_business_unit_ids = serializers.ListField( child=serializers.IntegerField(), required=False) tag_ids = serializers.ListField(child=serializers.IntegerField(), required=False) platforms = serializers.MultipleChoiceField(choices=PLATFORM_CHOICES, required=False) types = serializers.MultipleChoiceField(choices=TYPE_CHOICES, required=False) def validate(self, data): for key, val in data.items(): if val: return data raise serializers.ValidationError( "No business units, tags, platforms or types")
class ListingSerializer(serializers.ModelSerializer): thumbnail = serializers.SerializerMethodField(source='thumbnail') contractType = serializers.IntegerField(source='contract_type') acceptedCurrencies = serializers.MultipleChoiceField(choices=currency_list, default=['All']) price = serializers.SerializerMethodField() averageRating = serializers.FloatField(source='rating_average') ratingCount = serializers.FloatField(source='rating_count') freeShipping = serializers.ListField(source='free_shipping') class Meta: # exclude = ('condition_type', 'pricing_currency','contract_type', # 'rating_average','rating_count',) fields = ('thumbnail', 'contractType', 'acceptedCurrencies', 'price', 'averageRating', 'ratingCount', 'slug', 'nsfw', 'title', 'hash', 'freeShipping') model = Listing def get_thumbnail(self, o): try: return ImageMedSerializer(o.thumbnail[0]).data except (ListingImage.DoesNotExist, IndexError): return "" def get_price(self, o): return {"currencyCode": o.pricing_currency, "amount": o.price}
class ChefCreateListSerializer(serializers.ModelSerializer): id = serializers.IntegerField(read_only=True) name = serializers.CharField(required=True) description = serializers.CharField(required=False) email = serializers.CharField( required=True, validators=[UniqueValidator(queryset=Chef.objects.all())]) phone = serializers.CharField(required=True) cep_address = serializers.CharField(required=True, write_only=True) open_at = serializers.TimeField(required=True) close_at = serializers.TimeField(required=True) days_of_weak = serializers.MultipleChoiceField( required=True, choices=Chef.DAYS_OF_WEAK_CHOICES) date_joined = serializers.DateTimeField(read_only=True) last_update = serializers.DateTimeField(read_only=True) address = serializers.SerializerMethodField() def get_address(self, data): if isinstance(data, dict) and data.get('cep_address'): return get_address_by_cep(data.get('cep_address')) return data.address class Meta: model = Chef fields = ('cep_address', 'id', 'name', 'description', 'email', 'phone', 'address', 'open_at', 'close_at', 'days_of_weak', 'date_joined', 'last_update')
class SnippetSerializer(serializers.Serializer): """SnippetSerializer classdoc create: docstring for create from serializer classdoc """ id = serializers.IntegerField(read_only=True, help_text="id serializer help text") owner = serializers.PrimaryKeyRelatedField( queryset=get_user_model().objects.all(), default=serializers.CurrentUserDefault(), help_text= "The ID of the user that created this snippet; if none is provided, " "defaults to the currently logged in user.") owner_as_string = serializers.PrimaryKeyRelatedField( help_text="The ID of the user that created this snippet.", pk_field=serializers.CharField( help_text="this help text should not show up"), read_only=True, source='owner', ) title = serializers.CharField(required=False, allow_blank=True, max_length=100) code = serializers.CharField(style={'base_template': 'textarea.html'}) linenos = serializers.BooleanField(required=False) language = LanguageSerializer(help_text="Sample help text for language") styles = serializers.MultipleChoiceField(choices=STYLE_CHOICES, default=['friendly']) lines = serializers.ListField(child=serializers.IntegerField(), allow_empty=True, allow_null=True, required=False) example_projects = serializers.ListSerializer( child=ExampleProjectSerializer(), read_only=True) difficulty_factor = serializers.FloatField( help_text="this is here just to test FloatField", read_only=True, default=lambda: 6.9) def create(self, validated_data): """ Create and return a new `Snippet` instance, given the validated data. """ del validated_data['styles'] del validated_data['lines'] del validated_data['difficulty_factor'] return Snippet.objects.create(**validated_data) def update(self, instance, validated_data): """ Update and return an existing `Snippet` instance, given the validated data. """ instance.title = validated_data.get('title', instance.title) instance.code = validated_data.get('code', instance.code) instance.linenos = validated_data.get('linenos', instance.linenos) instance.language = validated_data.get('language', instance.language) instance.style = validated_data.get('style', instance.style) instance.save() return instance
class SubscriptionSerializer(serializers.Serializer): groups = serializers.MultipleChoiceField(choices=AppUser.USER_LEVEL) def save(self): request = self.context['request'] groups = self.validated_data['groups'] change_user_groups(request.user, groups)
class CustomerSerializer(serializers.ModelSerializer): cnh_type = serializers.MultipleChoiceField(choices=CNH_CHOICES) class Meta: model = Customer fields = ('first_name', 'last_name', 'username', 'email', 'cpf', 'cnh_type', 'password')
class InstituteRoleSerializer(serializers.ModelSerializer): permissions = serializers.MultipleChoiceField( choices=INSTITUTE_PERMISSION_CHOICES) class Meta: model = InstituteRole fields = ('id', 'name', 'permissions')
class HorarioMateriaListSerializer(serializers.ModelSerializer): class Meta: model = models.HorarioMateria exclude = ('id', 'materia') dias = serializers.MultipleChoiceField(choices=models.HorarioMateria.DIAS) aula = universidad_serializers.AulaSerializer(many=False, read_only=True) modo_profesores = ModoProfesorSerializer(many=False, read_only=True)
class ReftsParameterSerializer(serializers.Serializer): parameter = serializers.MultipleChoiceField( required=False, help_text="The parameters to get values for.", choices=[ "site_name", "site_code", "variable_name", "variable_code", "sample_medium", "method_link" ])
class UserListQuerySerializer(serializers.Serializer): username = serializers.CharField( help_text="this field is generated from a query_serializer", required=False) is_staff = serializers.BooleanField(help_text="this one too!", required=False) styles = serializers.MultipleChoiceField( help_text="and this one is fancy!", choices=('a', 'b', 'c', 'd'))
class GetGlobalModeratedObjectsSerializer(serializers.Serializer): max_id = serializers.IntegerField(required=False, ) count = serializers.IntegerField(required=False, max_value=20) types = serializers.MultipleChoiceField(choices=[ ModeratedObject.OBJECT_TYPE_POST, ModeratedObject.OBJECT_TYPE_POST_COMMENT, ModeratedObject.OBJECT_TYPE_COMMUNITY, ModeratedObject.OBJECT_TYPE_USER ], required=False) statuses = serializers.MultipleChoiceField(choices=[ ModeratedObject.STATUS_REJECTED, ModeratedObject.STATUS_PENDING, ModeratedObject.STATUS_APPROVED, ], required=False) verified = serializers.BooleanField(required=False, ) approved = serializers.BooleanField(required=False, )
class DailyRoundSerializer(serializers.ModelSerializer): additional_symptoms = serializers.MultipleChoiceField(choices=SYMPTOM_CHOICES, required=False) patient_category = ChoiceField(choices=CATEGORY_CHOICES, required=False) current_health = ChoiceField(choices=CURRENT_HEALTH_CHOICES, required=False) class Meta: model = DailyRound exclude = TIMESTAMP_FIELDS
class PositionProjectSerializer(serializers.ModelSerializer): company = PositionCompanySerializer(read_only=True) communication_languages = serializers.MultipleChoiceField( choices=LANGUAGES) job_type = serializers.MultipleChoiceField(choices=JOB_TYPE) salary = SalarySerilizer(allow_null=True, required=False) class Meta: model = Position fields = '__all__' extra_kwargs = { "position_title": { "error_messages": { "max_length": _("Please enter maximum 255 symbols") } }, }
class PositionRetrieveSerializer(serializers.ModelSerializer): company = PositionCompanySerializer(read_only=True) communication_languages = serializers.MultipleChoiceField( choices=LANGUAGES) job_type = serializers.MultipleChoiceField(choices=JOB_TYPE) project = ProjectSerializer(read_only=True) application_date = serializers.SerializerMethodField(read_only=True) technologies = TechnologySerializer(many=True) specialization = SpecializationSerializer(many=True) similar_jobs = serializers.SerializerMethodField( method_name='get_similar_jobs') class Meta: model = Position fields = ("id", "company", "communication_languages", "job_type", "project", "application_date", "technologies", "position_title", "experience", "experience_level", "requirements", "offers", "created", "modified", "specialization", "country", "similar_jobs") def get_application_date(self, obj): candidate = None user = self.context['request'].user if user.user_type == User.USER_TYPE_CANDIDATE: candidate = self.context.get('candidate') elif user.user_type == User.USER_TYPE_AGENCY: candidate = self.context.get('agency') if not candidate: return None application = candidate.position_applications\ .filter(position=obj).first() if not application: return None return application.created def get_similar_jobs(self, obj): similar_jobs = Position.objects.filter( technologies__in=obj.technologies.all()).distinct().exclude( pk=obj.pk)[:3] return PositionListSerializer(similar_jobs, many=True).data
class TableSerializer(serializers.Serializer): table_name = serializers.CharField(read_only=True) count = serializers.IntegerField(read_only=True) tables = serializers.MultipleChoiceField(choices=[], write_only=True) def __init__(self, *args, **kwargs): tables_choices = kwargs.pop('tables_choices', []) super(TableSerializer, self).__init__(*args, **kwargs) self.fields['tables'].choices = tables_choices
def test_against_partial_and_full_updates(self): # serializer = self.Serializer(data=MockHTMLDict()) from django.http import QueryDict field = serializers.MultipleChoiceField(choices=(('a', 'a'), ('b', 'b'))) field.partial = False assert field.get_value(QueryDict({})) == [] field.partial = True assert field.get_value(QueryDict({})) == rest_framework.fields.empty
class MerchantGroupSerializer(serializers.Serializer): """ MerchantGroup 绑定权限 创建、更新 """ name = serializers.CharField() notes = serializers.CharField(required=False) perms_code = serializers.MultipleChoiceField( choices=permissions_choice(), required=False, allow_empty=False, ) class Meta: model = MerchantGroup fields = ['name', 'notes', 'perms_code'] @transaction.atomic def update(self, instance, validated_data): merchant_group = instance print('merchant_group', merchant_group) print('validated_data', validated_data) merchant_group = update_merchant_group( merchant_group_id=merchant_group.id, name=validated_data.get('name', None), notes=validated_data.get('notes', None)) group = Group.objects.get(merchantgroup=merchant_group) codes = validated_data.get('perms_code', None) if codes: group.permissions.clear() perms = Permission.objects.filter(codename__in=codes) for i in perms: group.permissions.add(i) return merchant_group else: group.permissions.clear() return merchant_group @transaction.atomic def create(self, validated_data): print(validated_data) user = self.context['request'].user merchant = user.merchantuser.merchant merchant_group = create_merchant_group(name=validated_data['name'], user_id=user.id, merchant_id=merchant.id, notes=validated_data.get( 'notes', None)) group = Group.objects.get(merchantgroup=merchant_group) codes = validated_data.get('perms_code', None) if codes: perms = Permission.objects.filter(codename__in=codes) for i in perms: group.permissions.add(i) return merchant_group else: group.permissions.clear() return merchant_group