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()