class ServerLeaseSerializer(serializers.ModelSerializer):
tenant = serializers.PrimaryKeyRelatedField(read_only=True,
pk_field=HashidsIntegerField())
user = serializers.PrimaryKeyRelatedField(read_only=True,
pk_field=HashidsIntegerField())
class Meta:
model = ServerLease
fields = [
"server_id",
"server_name",
"tenant",
"user",
"created_at",
"last_renewed_at",
"expiry",
"renewal_count",
"renewal_url",
]
read_only_fields = [
"server_id",
"server_name",
"tenant",
"user",
"expiry",
"renewal_url",
]
class TenantSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
team = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
region = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
# from region to avoid nesting
disabled = serializers.SerializerMethodField()
new_instances_disabled = serializers.SerializerMethodField()
unshelving_disabled = serializers.SerializerMethodField()
class Meta:
model = Tenant
fields = [
"id",
"region",
"team",
"disabled",
"new_instances_disabled",
"unshelving_disabled",
]
def get_disabled(self, tenant):
return tenant.region.disabled
def get_new_instances_disabled(self, tenant):
return tenant.region.new_instances_disabled
def get_unshelving_disabled(self, tenant):
return tenant.region.unshelving_disabled
class TeamSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
default_region = serializers.PrimaryKeyRelatedField(
read_only=True, pk_field=HashidsIntegerField()
)
tenants = TenantSerializer(many=True, read_only=True)
class Meta:
model = Team
fields = [
"id",
"name",
"institution",
"department",
"phone_number",
"verified",
"default_region",
"tenants_available",
"tenants",
"licence_expiry",
"licence_is_valid",
]
read_only_fields = [
"id",
"name",
"verified",
"tenants_available",
"tenants",
"licence_expiry",
"licence_is_valid",
]
class UserTeamMembershipsSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
team = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
class Meta:
model = TeamMember
fields = ["id", "team"]
class ServerLeaseRequestSerializer(serializers.ModelSerializer):
server_lease = serializers.PrimaryKeyRelatedField(
read_only=True, pk_field=HashidsIntegerField())
user = serializers.PrimaryKeyRelatedField(read_only=True,
pk_field=HashidsIntegerField())
class Meta:
model = ServerLeaseRequest
fields = ["server_lease", "message", "user"]
class TeamMemberSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
team = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(), read_only=True
)
user = UserSerializer()
class Meta:
model = TeamMember
fields = ["id", "user", "team", "is_admin"]
class TenantSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
team = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
region = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
class Meta:
model = Tenant
fields = ["id", "region", "team"]
class LicenceAcceptanceSerializer(serializers.ModelSerializer):
team = serializers.PrimaryKeyRelatedField(read_only=True,
pk_field=HashidsIntegerField())
user = serializers.PrimaryKeyRelatedField(read_only=True,
pk_field=HashidsIntegerField())
version = LicenceVersionSerializer(read_only=True)
class Meta:
model = LicenceAcceptance
fields = ["team", "user", "version", "accepted_at", "expiry"]
read_only_fields = ["team", "user", "accepted_at", "version", "expiry"]
class HypervisorStatsSerializer(serializers.ModelSerializer):
region = serializers.PrimaryKeyRelatedField(pk_field=HashidsIntegerField(),
read_only=True)
class Meta:
model = HypervisorStats
exclude = ["id"]
class UserSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
profile = ProfileSerializer(many=False, read_only=False)
class Meta:
model = User
fields = ["id", "username", "first_name", "last_name", "email", "profile"]
read_only_fields = ["id", "username"]
def update(self, instance, validated_data):
is_new_email = instance.email != validated_data.get("email", instance.email)
instance.first_name = validated_data.get("first_name", instance.first_name)
instance.last_name = validated_data.get("last_name", instance.last_name)
instance.save()
profile = instance.profile
profile_data = validated_data.get("profile", None)
if profile_data:
profile.default_keypair = profile_data.get(
"default_keypair", profile.default_keypair
)
profile.save()
if is_new_email:
try:
new_email = validated_data.get("email")
profile.initiate_email_change(self.context["request"], new_email)
except ValueError:
raise serializers.ValidationError(
"An existing account is already associated with the new email address."
)
return instance
class InvitationSerializer(serializers.ModelSerializer):
to_team = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(), read_only=True
)
made_by = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Invitation
fields = ["uuid", "email", "date", "message", "made_by", "to_team"]
def validate(self, data):
team = get_object_or_404(
Team, pk=self.context["request"].resolver_match.kwargs["team_id"]
)
email = data["email"]
team_users = team.users
if Invitation.objects.filter(email=email, to_team=team, accepted=False).count():
raise serializers.ValidationError(
"There is already a pending invitation for this team and email address."
)
if team_users.filter(email=email).count():
raise serializers.ValidationError(
"There is already a current team member with this email address."
)
return data
class BucketSerializer(serializers.Serializer):
team = HashidsIntegerField(read_only=True)
name = serializers.CharField(
min_length=3, max_length=63, validators=[bucket_name_validator]
)
uri = serializers.URLField(read_only=True)
creation_date = serializers.DateTimeField(read_only=True)
is_public = serializers.BooleanField(default=False)
class UserSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
profile = ProfileSerializer(many=False, read_only=False)
team_memberships = UserTeamMembershipsSerializer(many=True, read_only=True)
two_factor_verified = serializers.SerializerMethodField()
class Meta:
model = User
fields = [
"id",
"username",
"first_name",
"last_name",
"email",
"profile",
"team_memberships",
"two_factor_verified",
]
read_only_fields = ["username"]
def get_two_factor_verified(self, obj):
"""
The method is_verified() is added through django-otp’s OTPMiddleware which can be used to check if the user was
logged in using two-factor authentication.
"""
return obj.is_verified()
def update(self, instance, validated_data):
is_new_email = instance.email != validated_data.get(
"email", instance.email)
instance.first_name = validated_data.get("first_name",
instance.first_name)
instance.last_name = validated_data.get("last_name",
instance.last_name)
instance.save()
profile = instance.profile
profile_data = validated_data.get("profile", None)
if profile_data:
profile.default_keypair = profile_data.get("default_keypair",
profile.default_keypair)
profile.default_team_membership = profile_data.get(
"default_team_membership", profile.default_team_membership)
profile.save()
if is_new_email:
try:
new_email = validated_data.get("email")
profile.initiate_email_change(self.context["request"],
new_email)
except ValueError:
raise serializers.ValidationError(
"An existing account is already associated with the new email address."
)
return instance
class CephUserSerializer(serializers.ModelSerializer):
team = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(), read_only=True
)
class Meta:
model = CephUser
fields = ["team", "is_owner", "uid", "api_keys"]
read_only_fields = ["uid", "team", "is_owner", "api_keys"]
class FrequentlyAskedQuestionSerializer(ModelSerializer):
id = HashidsIntegerField(read_only=True)
class Meta:
model = FrequentlyAskedQuestion
fields = [
"id",
"title",
"content",
"category",
]
class TeamMemberSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
team = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(),
read_only=True,
)
user = TeamMemberUserSerializer(read_only=True)
def update(self, instance, validated_data):
"""Support toggling of admin permissions only, via. update"""
if "is_admin" in validated_data:
is_admin = validated_data.get("is_admin")
if is_admin != instance.is_admin:
if is_admin:
instance.grant_admin_permissions()
else:
instance.revoke_admin_permissions()
return instance
class Meta:
model = TeamMember
fields = ["id", "user", "team", "is_admin", "is_owner"]
class AnnouncementSerializer(ModelSerializer):
id = HashidsIntegerField(read_only=True)
class Meta:
model = Announcement
fields = [
"id",
"title",
"content",
"category",
"created_at",
"updated_at",
]
class RegionSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
settings = RegionSettingsSerializer(source="regionsettings")
class Meta:
model = Region
fields = [
"id",
"name",
"description",
"disabled",
"disable_new_instances",
"settings",
]
class ProfileSerializer(serializers.ModelSerializer):
default_team_membership = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(),
queryset=TeamMember.objects.all(),
required=False,
allow_null=True,
)
class Meta:
model = Profile
fields = [
"default_keypair",
"default_team_membership",
"email_validated",
"new_email_pending_verification",
]
read_only_fields = [
"email_validated", "new_email_pending_verification"
]
class InstanceSerializer(OpenstackBaseSerializer):
id = serializers.UUIDField(read_only=True)
name = serializers.CharField()
flavor = serializers.UUIDField()
image = serializers.UUIDField(required=False)
keypair = serializers.CharField(required=False)
status = serializers.ChoiceField(choices=INSTANCE_STATUS_VALUES,
required=False)
ip = serializers.IPAddressField(read_only=True,
required=False,
allow_null=True)
created = serializers.DateTimeField(read_only=True)
lease_expiry = serializers.DateTimeField(read_only=True,
required=False,
allow_null=True)
lease_renewal_url = serializers.URLField(read_only=True,
required=False,
allow_null=True)
lease_assigned_teammember = serializers.PrimaryKeyRelatedField(
pk_field=HashidsIntegerField(), read_only=True)
class TeamMemberUserSerializer(serializers.ModelSerializer):
id = HashidsIntegerField(read_only=True)
class Meta:
model = User
fields = ["id", "username", "first_name", "last_name", "email"]
class OpenstackBaseSerializer(serializers.Serializer):
team = HashidsIntegerField(read_only=True)
tenant = HashidsIntegerField(read_only=True)