class HarvestSerializer(BasicSerializer):
metadata_formats = ListField(child=CharField(), required=False)
sets = ListField(child=CharField(), required=False)
class TrainingsSerializer(Serializer):
name = CharField(max_length=50)
channel_key = CharField(max_length=50)
class BasePackage822Serializer(SingleArtifactContentSerializer):
"""
A Serializer for abstract BasePackage used for conversion from 822 format.
"""
TRANSLATION_DICT = {
"package": "Package",
"source": "Source",
"version": "Version",
"architecture": "Architecture",
"section": "Section",
"priority": "Priority",
"origin": "Origin",
"tag": "Tag",
"bugs": "Bugs",
"essential": "Essential",
"build_essential": "Build_essential",
"installed_size": "Installed_size",
"maintainer": "Maintainer",
"original_maintainer": "Original_Maintainer",
"description": "Description",
"description_md5": "Description_MD5",
"homepage": "Homepage",
"built_using": "Built_Using",
"auto_built_package": "Auto_Built_Package",
"multi_arch": "Multi_Arch",
"breaks": "Breaks",
"conflicts": "Conflicts",
"depends": "Depends",
"recommends": "Recommends",
"suggests": "Suggests",
"enhances": "Enhances",
"pre_depends": "Pre_Depends",
"provides": "Provides",
"replaces": "Replaces",
}
package = CharField()
source = CharField(required=False)
version = CharField()
architecture = CharField()
section = CharField()
priority = CharField()
origin = CharField(required=False)
tag = CharField(required=False)
bugs = CharField(required=False)
essential = YesNoField(required=False)
build_essential = YesNoField(required=False)
installed_size = CharField(required=False)
maintainer = CharField()
original_maintainer = CharField(required=False)
description = CharField()
description_md5 = CharField(required=False)
homepage = CharField(required=False)
built_using = CharField(required=False)
auto_built_package = CharField(required=False)
multi_arch = CharField(required=False)
breaks = CharField(required=False)
conflicts = CharField(required=False)
depends = CharField(required=False)
recommends = CharField(required=False)
suggests = CharField(required=False)
enhances = CharField(required=False)
pre_depends = CharField(required=False)
provides = CharField(required=False)
replaces = CharField(required=False)
def __init__(self, *args, **kwargs):
"""Initializer for BasePackage822Serializer."""
super().__init__(*args, **kwargs)
self.fields.pop("artifact")
if "relative_path" in self.fields:
self.fields["relative_path"].required = False
@classmethod
def from822(cls, data, **kwargs):
"""
Translate deb822.Package to a dictionary for class instatiation.
"""
return cls(
data={k: data[v] for k, v in cls.TRANSLATION_DICT.items() if v in data}, **kwargs
)
def to822(self, component=""):
"""Create deb822.Package object from model."""
ret = deb822.Packages()
for k, v in self.TRANSLATION_DICT.items():
value = self.data.get(k)
if value is not None:
ret[v] = value
try:
artifact = self.instance._artifacts.get()
ret["MD5sum"] = artifact.md5
ret["SHA1"] = artifact.sha1
ret["SHA256"] = artifact.sha256
except Artifact.DoesNotExist:
remote_artifact = RemoteArtifact.objects.filter(sha256=self.instance.sha256).first()
ret["MD5sum"] = remote_artifact.md5
ret["SHA1"] = remote_artifact.sha1
ret["SHA256"] = remote_artifact.sha256
ret["Filename"] = self.instance.filename(component)
return ret
class Meta(SingleArtifactContentSerializer.Meta):
fields = SingleArtifactContentSerializer.Meta.fields + (
"package",
"source",
"version",
"architecture",
"section",
"priority",
"origin",
"tag",
"bugs",
"essential",
"build_essential",
"installed_size",
"maintainer",
"original_maintainer",
"description",
"description_md5",
"homepage",
"built_using",
"auto_built_package",
"multi_arch",
"breaks",
"conflicts",
"depends",
"recommends",
"suggests",
"enhances",
"pre_depends",
"provides",
"replaces",
)
model = BasePackage
class FansSerializer(Serializer):
name = CharField()
price = DecimalField(max_digits=8, decimal_places=2)
content = CharField()
class CommentCreateSerializer(Serializer):
text = CharField(allow_blank=False)
def __init__(self, *args, **kwargs):
"""Se agrega dinámicamente USERNAME_FIELD a self.fields."""
super(JSONWebTokenSerializer, self).__init__(*args, **kwargs)
self.fields[self.username_field] = CharField()
self.fields['password'] = PasswordField(write_only=True)
class UserRegisterSerializer(ModelSerializer):
"""
A serializer to register a new user.
"""
password = CharField(
write_only=True,
style={'input_type': 'password'}
)
confirm_password = CharField(
write_only=True,
style={'input_type': 'password'}
)
last_login = DateTimeField(
read_only=True
)
disciplines = SerializerMethodField()
classes = SerializerMethodField()
class Meta:
model = User
fields = (
'id', 'name', 'email', 'institution', 'course', 'photo',
'is_teacher', 'disciplines', 'classes', 'last_login',
'created_at', 'updated_at', 'password', 'confirm_password'
)
def get_disciplines(self, obj):
"""
If user is a teacher get his disciplines.
"""
if obj.is_teacher:
queryset = Discipline.objects.filter(teacher=obj.id)
disciplines = []
for discipline in queryset:
disciplines.append(discipline.id)
return disciplines
else:
return []
def get_classes(self, obj):
"""
If user is a student get their classes.
"""
if not obj.is_teacher:
return []
else:
return []
@staticmethod
def validate(data):
"""
Validate if existis another user with same email address and verify
if the password not match.
"""
email = data['email']
password = data['password']
confirm_password = data['confirm_password']
# Verify if exists another user with same email address
user = User.objects.filter(email=email)
if user.exists():
raise ValidationError(_('This user has already registered.'))
# Verify if the passwords not match.
if password != confirm_password:
raise ValidationError(_('The passwords do not match.'))
return data
@staticmethod
def create(validated_data):
"""
Create and return a new user.
"""
if validated_data['is_teacher'] is True:
user = Teacher(
email=validated_data['email'],
name=validated_data['name'],
is_teacher=validated_data['is_teacher'],
)
else:
user = Student(
email=validated_data['email'],
name=validated_data['name'],
is_teacher=validated_data['is_teacher'],
)
user.set_password(validated_data['password'])
user.save()
return user
class BookSerializer(ModelSerializer):
name = CharField(read_only=True)
class Meta:
model = Book
fields = ('id', 'name')
from django.contrib.auth import get_user_model
class LoginSerializer(Serializer):
username = CharField()
password = CharField()
class ChangePasswordSerializer(Serializer[T]):
old_password = CharField(required=True)
new_password = CharField(required=True)
class RegisterSerializer(ModelSerializer):
first_name = CharField(label='First name')
last_name = CharField(label='Last name')
username = CharField(label='Username')
email = EmailField(label='E-mail')
email_confirmation = EmailField(label='Confirm E-mail')
password = CharField(label='Password')
password_confirmation = CharField(label='Confirm Password')
class Meta:
model = User
fields = [
'first_name',
'last_name',
'username',
'email',
'email_confirmation',
'password',
'password_confirmation',
]
extra_kwargs = {'password': {'write_only': True}}
def create(self, validated_data):
# username = self.validated_data.get('username')
first_name = validated_data['first_name']
last_name = validated_data['last_name']
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user = User(
first_name=first_name,
last_name=last_name,
username=username,
email=email,
)
user.set_password(password)
user.is_active = False
user.save()
user.account.send_activation_email()
return validated_data
def validate_username(self, username):
qs = User.objects.filter(username__iexact=username)
if qs.exists():
raise ValidationError(
'This username is already registered before!')
return username
def validate_email_confirmation(self, email_confirmation):
data = self.get_initial()
email = data.get('email')
# email_confirmation = data.get('email_confirmation')
email_confirmation = email_confirmation
if email != email_confirmation:
raise ValidationError('Email dose not matched!')
qs = User.objects.filter(email__iexact=email_confirmation)
if qs.exists():
raise ValidationError('This email is already registered before!')
return email_confirmation
def validate_password_confirmation(self, password_confirmation):
data = self.get_initial()
password = data.get('password')
password_confirmation = password_confirmation
if password != password_confirmation:
raise ValidationError('Passwords dose not matched!')
return password_confirmation
class PyPostPublishSerializer(ModelSerializer):
tag = CharField()
class Meta:
model = Post
fields = ('title', 'content', 'tag', 'degree')
class FingerprintSerializer(ModelSerializer):
"""Serializer for the Fingerprint model."""
# Scan information
report_id = PrimaryKeyRelatedField(queryset=FactCollection.objects.all())
# Common facts
name = CharField(required=False, max_length=256)
os_name = CharField(required=False, max_length=64)
os_release = CharField(required=False, max_length=128)
os_version = CharField(required=False, max_length=64)
infrastructure_type = ChoiceField(
required=False, choices=SystemFingerprint.INFRASTRUCTURE_TYPE)
mac_addresses = CustomJSONField(required=False)
ip_addresses = CustomJSONField(required=False)
cpu_count = IntegerField(required=False, min_value=0)
architecture = CharField(required=False, max_length=64)
# Network scan facts
bios_uuid = CharField(required=False, max_length=36)
subscription_manager_id = CharField(required=False, max_length=36)
cpu_socket_count = IntegerField(required=False, min_value=0)
cpu_core_count = FloatField(required=False, min_value=0)
system_creation_date = DateField(required=False)
virtualized_type = CharField(required=False, max_length=64)
# VCenter scan facts
vm_state = CharField(required=False, max_length=24)
vm_uuid = CharField(required=False, max_length=36)
vm_dns_name = CharField(required=False, max_length=128)
vm_host = CharField(required=False, max_length=128)
vm_host_socket_count = IntegerField(required=False, min_value=0)
vm_cluster = CharField(required=False, max_length=128)
vm_datacenter = CharField(required=False, max_length=128)
products = ProductSerializer(many=True, allow_null=True, required=False)
entitlements = EntitlementSerializer(many=True,
allow_null=True,
required=False)
# Red Hat facts
is_redhat = NullBooleanField(required=False)
redhat_certs = CharField(required=False, max_length=128)
# pylint: disable=invalid-name
redhat_package_count = IntegerField(required=False, min_value=0)
metadata = CustomJSONField(required=True)
sources = CustomJSONField(required=True)
class Meta:
"""Meta class for FingerprintSerializer."""
model = SystemFingerprint
fields = '__all__'
def create(self, validated_data):
"""Create a system fingerprint."""
products_data = validated_data.pop('products', [])
entitlements_data = validated_data.pop('entitlements', [])
fingerprint = SystemFingerprint.objects.create(**validated_data)
for product_data in products_data:
Product.objects.create(fingerprint=fingerprint, **product_data)
for entitlement_data in entitlements_data:
Entitlement.objects.create(fingerprint=fingerprint,
**entitlement_data)
return fingerprint
class AccessDeniedChallenge(Challenge):
"""Challenge when a flow's active stage calls `stage_invalid()`."""
error_message = CharField(required=False)
class ShortProfileSerializer(ModelSerializer):
status = CharField(source='get_status_display')
class Meta:
model = models.Profile
fields = ('id', 'nickname', 'image', 'status')
class PermissionSerializer(PassiveSerializer):
"""Permission used for consent"""
name = CharField()
id = CharField()
class FullUserSerializer(serializers.ModelSerializer):
"""Full read-write User serializer for superuser access"""
ngp_id = CharField(source="person.ngp_id", required=False)
activity_status = serializers.SerializerMethodField()
added_by = LimitedUserSerializer(required=False, read_only=True)
is_mobilize_america_signup = serializers.BooleanField(required=False)
should_send_invite_email = serializers.BooleanField(required=False)
def get_activity_status(self, obj):
"""Currently activity status follows rules below:
ACTIVE: last_login within in in past week
INACTIVE: last_login > two weeks
CHURNING: last_login > one week and <two weeks
NEW: no last_login
"""
now = timezone.now()
last_week = now - datetime.timedelta(days=7)
two_weeks_ago = now - datetime.timedelta(days=14)
if obj.last_login:
if obj.last_login < two_weeks_ago:
return ActivityStatus.INACTIVE
elif obj.last_login > last_week:
return ActivityStatus.ACTIVE
else:
return ActivityStatus.CHURNING
else:
return ActivityStatus.NEW
class Meta:
model = User
fields = [
"id",
"is_admin",
"created_at",
"updated_at",
"person",
"first_name",
"last_name",
"email",
"phone",
"address",
"city",
"state",
"zip5",
"coordinates",
"ngp_id",
"last_login",
"activity_status",
"added_by",
"self_reported_team_name",
"is_mobilize_america_signup",
"should_send_invite_email",
]
# would want to update ngp_id on the person and not here
read_only_fields = [
"id", "created_at", "updated_at", "ngp_id", "is_admin"
]
# By default, email will have a uniqueness validator; we don't want to
# validate uniqueness on email, because we allow upsert.
extra_kwargs = {"email": {"validators": []}}
def update(self, instance, validated_data):
if "email" in validated_data:
raise ValidationError(
"Changing email is not allowed through this endpoint")
return super().update(instance, validated_data)
def create(self, validated_data):
"""Create or update based on email.
This results in POST behaving as an upsert based on email.
"""
email = validated_data.pop("email")
is_mobilize_america_signup = validated_data.pop(
"is_mobilize_america_signup", None)
should_send_invite_email = validated_data.pop(
"should_send_invite_email", False)
request = self.context.get("request")
if not request or not request.user:
raise ValidationError("Cannot create outside of a request context")
validated_data.update(added_by=request.user)
user = None
try:
existing_user = User.objects.get_user_by_email(email)
for k, v in validated_data.items():
setattr(existing_user, k, v)
existing_user.save()
user = existing_user
except User.DoesNotExist:
user = User.objects.create_user(None, email,
should_send_invite_email,
**validated_data)
if not is_mobilize_america_signup and user.verified_at is None:
# we pass in is_demo for the mobilize america sync only
VolProspectAssignment.objects.delete_demo_assignments(user)
user.verified_at = timezone.now()
user.save()
return user
class ServiceRequestSerializer(ModelSerializer):
class Meta:
model = Request
fields = [
'instance_name', 'billing_group', 'request_comment',
'fill_in_survey'
]
instance_name = CharField(
label="Squest instance name",
help_text=
"Help to identify the requested service in the 'Instances' view")
request_comment = CharField(label="Comment",
help_text="Add a comment to your request",
required=False)
billing_group = PrimaryKeyRelatedField(label='billing group id',
allow_null=True,
default=None,
required=False,
queryset=BillingGroup.objects.all(),
help_text="Billing group id")
def __init__(self, *args, **kwargs):
context = kwargs.get('context', None)
self.view = context.get('view', None)
self.service_id = self.view.kwargs.get('pk', None)
self.request = context.get('request', None)
super(ServiceRequestSerializer, self).__init__(*args, **kwargs)
if self.service_id is not None:
self.service = get_object_or_404(
Service.objects.filter(enabled=True), id=self.service_id)
# get the create operation of this service
self.create_operation = Operation.objects.get(
service=self.service, type=OperationType.CREATE)
# get all field that are not disabled by the admin
purged_survey = FormUtils.get_available_fields(
job_template_survey=self.create_operation.job_template.survey,
operation_survey=self.create_operation.tower_survey_fields)
self.fields['fill_in_survey'] = DynamicSurveySerializer(
fill_in_survey=purged_survey)
def validate_billing_group(self, value):
if not self.service.billing_group_is_selectable:
return None if self.service.billing_group_id is None else BillingGroup.objects.get(
id=self.service.billing_group_id)
if value is not None:
if self.service.billing_groups_are_restricted and value not in self.request.user.billing_groups.all(
):
raise ValidationError(
f"You are not authorized to request this service with the billing group {value.name}. "
f"Please choose among yours")
return value
def save(self):
# create the instance
instance_name = self.validated_data["instance_name"]
billing_group = None
if self.validated_data["billing_group"]:
billing_group = self.validated_data["billing_group"]
new_instance = Instance.objects.create(service=self.service,
name=instance_name,
billing_group=billing_group,
spoc=self.request.user)
# create the request
new_request = Request.objects.create(
instance=new_instance,
operation=self.create_operation,
fill_in_survey=self.validated_data["fill_in_survey"],
user=self.request.user)
# save the comment
message = None
if "request_comment" in self.validated_data and self.validated_data[
"request_comment"] is not None:
comment = self.validated_data["request_comment"]
message = RequestMessage.objects.create(request=new_request,
sender=self.request.user,
content=comment)
from service_catalog.mail_utils import send_mail_request_update
send_mail_request_update(target_request=new_request,
user_applied_state=new_request.user,
message=message)
return new_request
class CompanySerializer(Serializer):
letter_verification_code = CharField(max_length=10, read_only=True)
company_email = CharField(max_length=200, read_only=True)
is_verification_letter_sent = BooleanField(read_only=True)
class ArticleSerializer(Serializer):
name = CharField()
price = DecimalField(max_digits=8, decimal_places=2)
content = CharField()
fans = FansSerializer(many=True)
class ErrorDetailSerializer(PassiveSerializer):
"""Serializer for rest_framework's error messages"""
string = CharField()
code = CharField()
class UserCreateSerializer(ModelSerializer):
profile = ProfileSerializer()
conffPassword = CharField()
name = CharField()
class Meta:
model = Users
fields = [
'email',
'name',
'password',
'conffPassword',
'profile',
]
extra_kwayrgs = {
"password": {
"write_only": True
},
"conffPassword": {
"write_only": True
},
}
def perform_create(self, serializer):
return {serializer.save(user=self.request.user)}
def create(self, validated_data):
name = validated_data['name']
email = validated_data['email']
password = validated_data['password']
profile = validated_data['profile']
user_obj = Users(username=email, email=email)
nameList = name.split()
if len(nameList) == 1:
user_obj.first_name = name
else:
user_obj.first_name = nameList[0]
user_obj.last_name = ' '.join(nameList[1:])
user_obj.set_password(password)
user_obj
user_obj.save()
#set profile data
new_user = Users.objects.get(email=email)
print(new_user)
print(profile)
new_user.profile.dateOfBirth = profile["dateOfBirth"]
new_user.profile.gender = profile["gender"]
new_user.profile.phone = profile["phone"]
new_user.profile.city = profile["city"]
new_user.profile.country = profile["country"]
new_user.profile.height = profile["height"]
new_user.profile.weight = profile["weight"]
new_user.profile.smoking = profile["smoking"]
new_user.save()
token = get_tokens_for_user(new_user)
"""
validated_data["token"] = token
print(validated_data)
"""
return validated_data
#Validations
def validate_email(self, value):
data = self.get_initial()
email = value
user_qs = Users.objects.filter(email=email)
if user_qs.exists():
raise ValidationError("This email has already registered")
return value
def validate_password(self, value):
data = self.get_initial()
confpassword = data.get("conffPassword")
password = value
if password != confpassword:
raise ValidationError("Password must match.")
return value
class RedirectChallenge(Challenge):
"""Challenge type to redirect the client"""
to = CharField()
class ProgramAdminSerializer(ModelSerializer):
id = IntegerField(allow_null=True, required=False)
name = CharField(required=True, max_length=255)
funding_status = CharField(required=True)
gaitid = CharField(required=False, allow_blank=True, allow_null=True)
description = CharField(allow_null=True, allow_blank=True)
sector = NestedSectorSerializer(required=True, many=True)
country = NestedCountrySerializer(required=True, many=True)
auto_number_indicators = BooleanField(required=False)
_using_results_framework = IntegerField(required=False, allow_null=True)
def validate_country(self, values):
if not values:
raise ValidationError("This field may not be blank.")
return values
class Meta:
model = Program
fields = (
'id',
'name',
'funding_status',
'gaitid',
'description',
'sector',
'country',
'auto_number_indicators',
'_using_results_framework'
)
def to_representation(self, program, with_aggregates=True):
ret = super(ProgramAdminSerializer, self).to_representation(program)
if not with_aggregates:
return ret
# Some n+1 queries here. If this is slow, Fix in queryset either either with rawsql or remodel.
program_users = (
TolaUser.objects.filter(programs__id=program.id).select_related('organization')
| TolaUser.objects.filter(countries__program=program.id).select_related('organization')
).distinct()
organizations = set(tu.organization_id for tu in program_users if tu.organization_id)
organization_count = len(organizations)
ret['program_users'] = len(program_users)
ret['organizations'] = organization_count
ret['onlyOrganizationId'] = organizations.pop() if organization_count == 1 else None
if ret['_using_results_framework'] == Program.RF_ALWAYS:
ret.pop('_using_results_framework')
return ret
@transaction.atomic
def create(self, validated_data):
if '_using_results_framework' in validated_data and \
validated_data['_using_results_framework'] is None:
validated_data.pop('_using_results_framework')
country = validated_data.pop('country')
sector = validated_data.pop('sector')
if not validated_data['gaitid']:
validated_data.pop('gaitid')
program = super(ProgramAdminSerializer, self).create(validated_data)
program.country.add(*country)
program.sector.add(*sector)
program.save()
ProgramAdminAuditLog.created(
program=program,
created_by=self.context.get('request').user.tola_user,
entry=program.admin_logged_fields,
)
return program
@transaction.atomic
def update(self, instance, validated_data):
previous_state = instance.admin_logged_fields
if '_using_results_framework' in validated_data and validated_data['_using_results_framework'] is None:
validated_data['_using_results_framework'] = instance._using_results_framework
# default for any unmigrated program is "auto" - so if someone sets their program to "not grouping" - reset it
# to default ("auto")
if ('_using_results_framework' in validated_data
and validated_data['_using_results_framework'] == instance.NOT_MIGRATED):
validated_data['auto_number_indicators'] = True
original_countries = instance.country.all()
incoming_countries = validated_data.pop('country')
added_countries = [x for x in incoming_countries if x not in original_countries]
removed_countries = [x for x in original_countries if x not in incoming_countries]
original_sectors = instance.sector.all()
incoming_sectors = validated_data.pop('sector')
added_sectors = [x for x in incoming_sectors if x not in original_sectors]
removed_sectors = [x for x in original_sectors if x not in incoming_sectors]
instance.country.remove(*removed_countries)
instance.country.add(*added_countries)
instance.sector.remove(*removed_sectors)
instance.sector.add(*added_sectors)
ProgramAccess.objects.filter(program=instance, country__in=removed_countries).delete()
updated_instance = super(ProgramAdminSerializer, self).update(instance, validated_data)
ProgramAdminAuditLog.updated(
program=instance,
changed_by=self.context.get('request').user.tola_user,
old=previous_state,
new=instance.admin_logged_fields,
)
return updated_instance
class ShellChallenge(Challenge):
"""Legacy challenge type to render HTML as-is"""
body = CharField()
class TrainingStatusSerializer(Serializer):
status = CharField(max_length=50)
class WithUserInfoChallenge(Challenge):
"""Challenge base which shows some user info"""
pending_user = CharField()
pending_user_avatar = CharField()
class BasePackageSerializer(SingleArtifactContentUploadSerializer, ContentChecksumSerializer):
"""
A Serializer for abstract BasePackage.
"""
package = CharField(read_only=True)
source = CharField(read_only=True)
version = CharField(read_only=True)
architecture = CharField(read_only=True)
section = CharField(read_only=True)
priority = CharField(read_only=True)
origin = CharField(read_only=True)
tag = CharField(read_only=True)
bugs = CharField(read_only=True)
essential = YesNoField(read_only=True)
build_essential = YesNoField(read_only=True)
installed_size = CharField(read_only=True)
maintainer = CharField(read_only=True)
original_maintainer = CharField(read_only=True)
description = CharField(read_only=True)
description_md5 = CharField(read_only=True)
homepage = CharField(read_only=True)
built_using = CharField(read_only=True)
auto_built_package = CharField(read_only=True)
multi_arch = CharField(read_only=True)
breaks = CharField(read_only=True)
conflicts = CharField(read_only=True)
depends = CharField(read_only=True)
recommends = CharField(read_only=True)
suggests = CharField(read_only=True)
enhances = CharField(read_only=True)
pre_depends = CharField(read_only=True)
provides = CharField(read_only=True)
replaces = CharField(read_only=True)
def __init__(self, *args, **kwargs):
"""Initializer for BasePackageSerializer."""
super().__init__(*args, **kwargs)
if "relative_path" in self.fields:
self.fields["relative_path"].required = False
def deferred_validate(self, data):
"""Validate that the artifact is a package and extract it's values."""
data = super().deferred_validate(data)
try:
package_paragraph = debfile.DebFile(fileobj=data["artifact"].file).debcontrol()
except Exception: # TODO: Be more specific
raise ValidationError(_("Not a valid Deb Package"))
from822_serializer = self.Meta.from822_serializer.from822(data=package_paragraph)
from822_serializer.is_valid(raise_exception=True)
package_data = from822_serializer.validated_data
data.update(package_data)
data["sha256"] = data["artifact"].sha256
if "relative_path" not in data:
data["relative_path"] = self.Meta.model(**package_data).filename()
elif not os.path.basename(data["relative_path"]) == "{}.{}".format(
self.Meta.model(**package_data).name, self.Meta.model.SUFFIX
):
raise ValidationError(_("Invalid relative_path provided, filename does not match."))
content = self.Meta.model.objects.filter(
sha256=data["sha256"], relative_path=data["relative_path"]
)
if content.exists():
raise ValidationError(
_(
"There is already a deb package with relative path '{path}' and sha256 "
"'{sha256}'."
).format(path=data["relative_path"], sha256=data["sha256"])
)
return data
class Meta(SingleArtifactContentUploadSerializer.Meta):
fields = (
SingleArtifactContentUploadSerializer.Meta.fields
+ ContentChecksumSerializer.Meta.fields
+ (
"package",
"source",
"version",
"architecture",
"section",
"priority",
"origin",
"tag",
"bugs",
"essential",
"build_essential",
"installed_size",
"maintainer",
"original_maintainer",
"description",
"description_md5",
"homepage",
"built_using",
"auto_built_package",
"multi_arch",
"breaks",
"conflicts",
"depends",
"recommends",
"suggests",
"enhances",
"pre_depends",
"provides",
"replaces",
)
)
model = BasePackage
class ResourceLinkSerializer(Serializer):
href = CharField()
type = CharField()
