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
