class PollConfigSerializer(Serializer):
equal_width = BooleanField(default=False)
title = CharField()
options = ListField(child=CharField(), allow_empty=False)
lifetime = ChoiceField(choices=_PollLifetime.CHOICES,
default=_PollLifetime.MONTH)
def create(self, validated_data):
poll_expires_at = timezone.now() + _PollLifetime.to_relativedelta(
validated_data['lifetime'])
poll_equal_width = validated_data['equal_width']
poll_title = safe_html(validated_data['title'])
poll_option_names = [
safe_html(str(option_name))
for option_name in validated_data['options']
]
with transaction.atomic():
poll = Poll.objects.create(title=poll_title,
expires_at=poll_expires_at,
equal_width=poll_equal_width)
for i, option_name in enumerate(poll_option_names):
PollOption.objects.create(poll=poll,
position=i,
name=option_name)
return poll
class BillableItemSerializer(Serializer):
type = ChoiceField([
'missed_reservation', 'tool_usage', 'area_access', 'consumable',
'staff_charge', 'training_session'
])
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)
user = CharField(max_length=255, 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 = DecimalField(read_only=True, decimal_places=2, max_digits=8)
def update(self, instance, validated_data):
pass
def create(self, validated_data):
pass
class Meta:
fields = '__all__'
def test_to_internal_value(self):
f = ImplicitExpandableListField(child=ChoiceField(
choices=["foo", "foo__bar", "bar"]))
self.assertEqual(f.run_validation(["foo"]), ["foo"])
self.assertEqual(set(f.run_validation(["foo__bar"])),
{"foo__bar", "foo"})
class UserCreateSerializer(ModelSerializer):
username = CharField(validators=[UniqueValidator(queryset=User.objects.all())])
# need to make email optional ... prob should think through signup form a little
email = CharField(
validators=[UniqueValidator(queryset=User.objects.all())], required=False
)
password = CharField(write_only=True, min_length=8)
signed_up_from = CharField(
write_only=True, min_length=8, required=False, default="", trim_whitespace=True
)
timezone_string = ChoiceField(
choices=pytz.all_timezones, required=False, default="US/Eastern"
)
class Meta:
model = User
fields = ["username", "email", "password", "signed_up_from", "timezone_string"]
# TODO test - does this work with just username / no email, etc.
def create(self, validated_data):
username = validated_data.pop("username")
password = validated_data.pop("password")
is_betterself_user = False
if validated_data["signed_up_from"] == "betterself":
is_betterself_user = True
validated_data["is_betterself_user"] = is_betterself_user
user = User.objects.create(username=username, **validated_data)
user.set_password(password)
user.save()
return user
class DailyProductivityLogCreateUpdateSerializer(
BaseCreateUpdateSerializer, ModelValidatorsMixin
):
# allow an regular isoformat of milliseconds also be passed
date = DateField(input_formats=["iso-8601"])
source = ChoiceField(choices=BETTERSELF_LOG_INPUT_SOURCES, default=WEB_INPUT_SOURCE)
mistakes = CharField(trim_whitespace=True, default="", allow_blank=True)
class Meta:
model = DailyProductivityLog
fields = (
"source",
"date",
"very_productive_time_minutes",
"productive_time_minutes",
"neutral_time_minutes",
"distracting_time_minutes",
"very_distracting_time_minutes",
"pomodoro_count",
"notes",
"mistakes",
"user",
)
def validate(self, validated_data):
user = self.context["request"].user
is_creating_instance = not self.instance
if is_creating_instance:
if self.Meta.model.objects.filter(
user=user, date=validated_data["date"],
).exists():
raise ValidationError(f"Fields user and date need to be unique!")
return validated_data
class TaskSerializer(PassiveSerializer):
"""Serialize TaskInfo and TaskResult"""
task_name = CharField()
task_description = CharField()
task_finish_timestamp = DateTimeField(source="finish_time")
status = ChoiceField(
source="result.status.name",
choices=[(x.name, x.name) for x in TaskResultStatus],
)
messages = ListField(source="result.messages")
def to_representation(self, instance):
"""When a new version of authentik adds fields to TaskInfo,
the API will fail with an AttributeError, as the classes
are pickled in cache. In that case, just delete the info"""
try:
return super().to_representation(instance)
except AttributeError: # pragma: no cover
if isinstance(self.instance, list):
for inst in self.instance:
inst.delete()
else:
self.instance.delete()
return {}
class WellBeingLogCreateUpdateSerializer(BaseCreateUpdateSerializer,
ModelValidatorsMixin):
source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE)
class Meta:
model = WellBeingLog
fields = (
"mental_value",
"physical_value",
"time",
"source",
"notes",
"user",
)
def validate(self, validated_data):
user = self.context["request"].user
is_creating_instance = not self.instance
if is_creating_instance:
if self.Meta.model.objects.filter(
user=user,
time=validated_data["time"],
).exists():
raise ValidationError(f"Fields user and time are not unique!")
return validated_data
class LoadAccountSerializer(serializers.Serializer):
"""
First tried to just declare a djmoney.contrib.MoneyField, but currency was still missing from the representation.
(The currency we can see in the documentation only comes to life when there is a database MoneyField in a model).
"""
amount = DecimalField(max_digits=12, decimal_places=2)
amount_currency = ChoiceField(choices=CURRENCY_CHOICES, default=DEFAULT_CURRENCY)
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
error_reporting_enabled = BooleanField(read_only=True)
error_reporting_environment = CharField(read_only=True)
error_reporting_send_pii = BooleanField(read_only=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
class UsedBySerializer(PassiveSerializer):
"""A list of all objects referencing the queried object"""
app = CharField()
model_name = CharField()
pk = CharField()
name = CharField()
action = ChoiceField(choices=[(x.name, x.name) for x in DeleteAction])
class ReportSerializer(ModelSerializer):
object_type = ChoiceField(
["question", "answer", "comment", "profile", "tag", "course"])
comments = ModeratorCommentSerializer(many=True, required=False)
class Meta:
model = Report
fields = (
"pk",
"created_at",
"updated_at",
"closed_at",
"text",
"reporter",
"status",
"object_id",
"object_type",
"comments",
)
read_only_fields = (
"pk",
"created_at",
"updated_at",
"closed_at",
"reporter",
"status",
"comments",
)
def create(self, validated_data):
report = Report(
reporter=Profile.objects.get_or_create(
user=self.context["request"].user)[0],
text=validated_data["text"],
object_id=validated_data["object_id"],
)
if validated_data["object_type"] == "question":
report.content_type = ContentType.objects.get(app_label="question",
model="question")
elif validated_data["object_type"] == "answer":
report.content_type = ContentType.objects.get(app_label="question",
model="answer")
elif validated_data["object_type"] == "comment":
report.content_type = ContentType.objects.get(app_label="question",
model="comment")
elif validated_data["object_type"] == "profile":
report.content_type = ContentType.objects.get(app_label="account",
model="profile")
elif validated_data["object_type"] == "tag":
report.content_type = ContentType.objects.get(app_label="question",
model="questiontag")
if report.content_object is None:
raise ParseError()
report.save()
return report
class WarningSerializer(serializers.ModelSerializer):
name = ChoiceField(choices=Warning.WARNINGS_CHOICES)
class Meta:
model = Warning
fields = (
'id',
'name',
)
class StagePromptSerializer(PassiveSerializer):
"""Serializer for a single Prompt field"""
field_key = CharField()
label = CharField(allow_blank=True)
type = ChoiceField(choices=FieldTypes.choices)
required = BooleanField()
placeholder = CharField(allow_blank=True)
order = IntegerField()
sub_text = CharField(allow_blank=True)
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
error_reporting = ErrorReportingConfigSerializer(required=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
cache_timeout = IntegerField(required=True)
cache_timeout_flows = IntegerField(required=True)
cache_timeout_policies = IntegerField(required=True)
cache_timeout_reputation = IntegerField(required=True)
class SourceCreateSerializer(SourceCreateOrUpdateSerializer):
type = CharField(source='resource_type', read_only=True)
uuid = CharField(source='id', read_only=True)
id = CharField(required=True,
validators=[RegexValidator(regex=NAMESPACE_REGEX)],
source='mnemonic')
short_code = CharField(source='mnemonic', read_only=True)
name = CharField(required=True)
full_name = CharField(required=False)
description = CharField(required=False, allow_blank=True)
source_type = CharField(required=False, allow_blank=True)
custom_validation_schema = CharField(required=False,
allow_blank=True,
allow_null=True)
public_access = ChoiceField(required=False, choices=ACCESS_TYPE_CHOICES)
default_locale = CharField(required=False, allow_blank=True)
supported_locales = ListField(required=False, allow_empty=True)
website = CharField(required=False, allow_blank=True)
url = CharField(read_only=True)
canonical_url = CharField(required=False,
allow_null=True,
allow_blank=True)
versions_url = CharField(read_only=True)
concepts_url = CharField(read_only=True)
mappings_url = CharField(read_only=True)
owner = CharField(source='parent_resource', read_only=True)
owner_type = CharField(source='parent_resource_type', read_only=True)
owner_url = CharField(source='parent_url', read_only=True)
versions = IntegerField(source='num_versions', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
created_by = CharField(source='owner', read_only=True)
updated_by = CharField(read_only=True)
extras = JSONField(required=False, allow_null=True)
external_id = CharField(required=False, allow_blank=True)
user_id = PrimaryKeyRelatedField(required=False,
queryset=UserProfile.objects.all(),
allow_null=True)
organization_id = PrimaryKeyRelatedField(
required=False, queryset=Organization.objects.all(), allow_null=True)
version = CharField(default=HEAD)
def create(self, validated_data):
source = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Source.persist_new(source, user)
self._errors.update(errors)
return source
def create_version(self, validated_data):
source = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Source.persist_new_version(source, user)
self._errors.update(errors)
return source
class TableViewSerializer(EmbeddedDocumentSerializer):
shared_group = BEmbeddedListField(serializer=SharedGroupSerializer)
name = CharField(required=True)
model = CharField(required=True)
is_default = BooleanField(default=False)
access = ChoiceField(choices=['private', 'public', 'restrict'], required=False)
query = ListField(child=ViewQuerySerializer(many=False, read_only=False, allow_null=True, required=False))
class Meta:
model = TableView
fields = '__all__'
class Challenge(PassiveSerializer):
"""Challenge that gets sent to the client based on which stage
is currently active"""
type = ChoiceField(choices=[(x.value, x.name) for x in ChallengeTypes], )
component = CharField(required=False)
title = CharField(required=False)
background = CharField(required=False)
response_errors = DictField(child=ErrorDetailSerializer(many=True),
allow_empty=True,
required=False)
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
branding_logo = CharField(read_only=True)
branding_title = CharField(read_only=True)
ui_footer_links = ListField(child=FooterLinkSerializer(), read_only=True)
error_reporting_enabled = BooleanField(read_only=True)
error_reporting_environment = CharField(read_only=True)
error_reporting_send_pii = BooleanField(read_only=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
class TaskSerializer(PassiveSerializer):
"""Serialize TaskInfo and TaskResult"""
task_name = CharField()
task_description = CharField()
task_finish_timestamp = DateTimeField(source="finish_timestamp")
status = ChoiceField(
source="result.status.name",
choices=[(x.name, x.name) for x in TaskResultStatus],
)
messages = ListField(source="result.messages")
class Challenge(PassiveSerializer):
"""Challenge that gets sent to the client based on which stage
is currently active"""
type = ChoiceField(
choices=[(x.value, x.name) for x in ChallengeTypes],
)
flow_info = ContextualFlowInfo(required=False)
component = CharField(default="")
response_errors = DictField(
child=ErrorDetailSerializer(many=True), allow_empty=True, required=False
)
class SupplementLogCreateUpdateSerializer(BaseCreateUpdateSerializer):
supplement_uuid = UUIDField(source="supplement.uuid")
user = HiddenField(default=CurrentUserDefault())
uuid = UUIDField(required=False, read_only=True)
notes = CharField(
default="",
trim_whitespace=True,
required=False,
allow_blank=True,
)
quantity = DecimalField(decimal_places=4, max_digits=10, default=1)
source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE)
class Meta:
model = SupplementLog
fields = (
"user",
"uuid",
"notes",
"supplement_uuid",
"source",
"quantity",
"time",
"duration_minutes",
)
def validate_supplement_uuid(self, value):
user = self.context["request"].user
validate_model_uuid(Supplement, uuid=value, user=user)
return value
def validate(self, validated_data):
user = self.context["request"].user
is_creating_instance = not self.instance
if validated_data.get("supplement"):
supplement_uuid = validated_data["supplement"]["uuid"]
supplement = Supplement.objects.get(uuid=supplement_uuid,
user=user)
validated_data["supplement"] = supplement
if is_creating_instance:
if self.Meta.model.objects.filter(
user=user,
supplement=supplement,
time=validated_data["time"],
).exists():
raise ValidationError(
f"Fields user, supplement, and time are not unique!")
return validated_data
class OAuthSourceSerializer(SourceSerializer):
"""OAuth Source Serializer"""
provider_type = ChoiceField(choices=MANAGER.get_name_tuple())
callback_url = SerializerMethodField()
def get_callback_url(self, instance: OAuthSource) -> str:
"""Get OAuth Callback URL"""
relative_url = reverse_lazy(
"authentik_sources_oauth:oauth-client-callback",
kwargs={"source_slug": instance.slug},
)
if "request" not in self.context:
return relative_url
return self.context["request"].build_absolute_uri(relative_url)
type = SerializerMethodField()
@extend_schema_field(SourceTypeSerializer)
def get_type(self, instance: OAuthSource) -> SourceTypeSerializer:
"""Get source's type configuration"""
return SourceTypeSerializer(instance.type).data
def validate(self, attrs: dict) -> dict:
provider_type = MANAGER.find_type(attrs.get("provider_type", ""))
for url in [
"authorization_url",
"access_token_url",
"profile_url",
]:
if getattr(provider_type, url, None) is None:
if url not in attrs:
raise ValidationError(f"{url} is required for provider {provider_type.name}")
return attrs
class Meta:
model = OAuthSource
fields = SourceSerializer.Meta.fields + [
"provider_type",
"request_token_url",
"authorization_url",
"access_token_url",
"profile_url",
"consumer_key",
"consumer_secret",
"callback_url",
"additional_scopes",
"type",
]
extra_kwargs = {"consumer_secret": {"write_only": True}}
class EventSerializer(ModelSerializer):
id = CharField(read_only=True)
start = UnixEpochDateField()
locations = PrimaryKeyRelatedField(
many=True,
pk_field=CharField(),
queryset=LocationModel.objects.all().filter(deleted=False))
duration = DurationInSecondsField()
category = ChoiceField(choices=EventModel.CATEGORIES)
class Meta:
model = EventModel
fields = ('id', 'name', 'info', 'start', 'duration', 'locations',
'category', 'approved')
class ContactSerializer(serializers.Serializer):
"""Serializer for contact message."""
VOLUNTEER = 'volunteer'
ORGANIZATION = 'organization'
APPLICANT_CHOICES = (VOLUNTEER, ORGANIZATION)
applicant_type = ChoiceField(APPLICANT_CHOICES, required=True)
applicant_email = EmailField(required=True, max_length=150)
applicant_name = CharField(required=True, min_length=3, max_length=150)
administrator_email = EmailField(
required=True,
validators=[validate_admin_email],
)
message = CharField(required=True, min_length=10, max_length=2000)
phone_no = CharField(max_length=20)
class OrderListSerializer(ModelSerializer):
pizzas_number = SerializerMethodField()
customer = CustomerSerializer(read_only=True)
status = ChoiceField(choices=Order.STATUS_CHOICES, read_only=True)
pizzas = PizzaSerializer(many=True, read_only=True, source='pizzas.all')
@staticmethod
def get_pizzas_number(obj):
return obj.pizzas.count()
class Meta:
model = Order
ordering = ('-created', )
fields = ('id', 'pizzas', 'customer', 'status', 'details',
'pizzas_number')
class ArticleApprovalUpdateSerializer(ModelSerializer):
written_by = WriterDetailSerializer(read_only=True)
edited_by = WriterDetailSerializer(allow_null=True, read_only=True)
action = ChoiceField(write_only=True,
allow_blank=False,
choices=APPROVAL_STATUS_CHOICES)
class Meta:
model = Article
fields = ('id', 'title', 'content', 'status', 'created_at',
'written_by', 'edited_by', 'action')
extra_kwargs = {
'id': {
'read_only': True
},
'title': {
'read_only': True
},
'content': {
'read_only': True
},
'status': {
'read_only': True
},
'created_at': {
'read_only': True
},
}
def update(self, instance, validated_data):
# print('update')
action = validated_data.get('action', None)
if action is None:
raise ValidationError('Action field missing!')
if action == APPROVED:
instance.status = APPROVED
elif action == REJECTED:
instance.status = REJECTED
else:
raise ValidationError(
f"The field: 'action' must have one of the values:('{APPROVED},{REJECTED}')!"
)
# print(self.validated_data)
# print(self.context['writer'])
instance.edited_by = self.context['writer']
instance.save()
#
return instance
class RegistrationTrashSerializer(serializers.ModelSerializer):
consultant = UserBasicSerializer()
costumer = PersonSerializer()
status_removed = ChoiceField(choices=Registration.STATUS_CHOICES)
class Meta:
model = Registration
fields = [
'id',
'consultant',
'costumer',
'trash_date',
'deleted_date',
'status_removed',
'get_status_removed_display'
]
class SleepLogCreateUpdateSerializer(BaseCreateUpdateSerializer,
ModelValidatorsMixin):
source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE)
class Meta:
model = SleepLog
fields = (
"source",
"start_time",
"end_time",
"notes",
"user",
)
def validate(self, validated_data):
user = self.context["request"].user
is_creating_instance = not self.instance
end_time = validated_data.get("end_time") or self.instance.end_time
start_time = validated_data.get(
"start_time") or self.instance.start_time
if start_time > end_time:
raise ValidationError("End Time Must Occur After Start")
if is_creating_instance:
if self.Meta.model.objects.filter(
user=user,
start_time=validated_data["start_time"],
end_time=validated_data["end_time"],
).exists():
raise ValidationError(
f"Fields user, start_time, and end_time are not unique!")
queryset = SleepLog.objects.filter(user=user,
end_time__gte=start_time,
start_time__lte=end_time)
if queryset.exists():
duplicated = queryset.first()
start_time_label = duplicated.start_time.date()
raise ValidationError(
f"Sleep Periods cannot overlap! Found overlapping on {start_time_label}"
)
return validated_data
class MessageViewSerializer(serializers.ModelSerializer):
sender = UserSerializer()
chat = ChatViewSerializer()
status = ChoiceField(choices=STATUS.choices)
file_set = FileSerializer(many=True)
class Meta:
model = Message
fields = (
"id",
"sender",
"chat",
"text",
"status",
"created_at",
"updated_at",
"file_set",
)
class InstanceSerializer(ModelSerializer):
"""Serialize a customer AwsInstance for API v2."""
cloud_type = ChoiceField(choices=CLOUD_PROVIDERS, required=False)
content_object = GenericRelatedField(
{
AwsInstance: AwsInstanceSerializer(),
AzureInstance: AzureInstanceSerializer(),
},
required=False,
)
instance_id = IntegerField(source="id", read_only=True)
class Meta:
model = Instance
fields = (
"cloud_account_id",
"created_at",
"instance_id",
"machine_image_id",
"updated_at",
"cloud_type",
"content_object",
)
read_only_fields = (
"cloud_account_id",
"created_at",
"id",
"machine_image_id",
"updated_at",
)
def create(self, validated_data):
"""Create a Instance."""
raise NotImplementedError
def update(self, instance, validated_data):
"""Update a Instance."""
raise NotImplementedError
