class MoviesSerializer(ModelSerializer): # country = SlugRelatedField(many=True, read_only=True, slug_field='title') country = ListSerializer(child=serializers.CharField()) genres = ListSerializer(child=serializers.CharField()) # actors = serializers.StringRelatedField(many=True) actors = ParticipantsSerializer(many=True, read_only=True) # director = ListSerializer(child=serializers.CharField()) director = ParticipantsSerializer(many=True, read_only=True) class Meta: model = Movie fields = [ 'title', 'year', 'country', 'actors', 'director', 'genres', 'poster', 'description', 'url' ]
class UserSerializer(ModelSerializer): """User Serializer""" is_superuser = BooleanField(read_only=True) avatar = CharField(read_only=True) attributes = JSONField(validators=[is_dict], required=False) groups = ListSerializer(child=GroupSerializer(), read_only=True, source="ak_groups") uid = CharField(read_only=True) class Meta: model = User fields = [ "pk", "username", "name", "is_active", "last_login", "is_superuser", "groups", "email", "avatar", "attributes", "uid", ]
class TransactionSerializer(ModelSerializer): movements_specs = ListSerializer(child=MovementSpecSerializer(), source='get_movements_specs') class Meta: model = Transaction fields = ['pk', 'description', 'date', 'movements_specs'] read_only_fields = ['pk'] def create(self, validated_data): movements_data = validated_data.pop('get_movements_specs') validated_data['movements_specs'] = [ MovementSpecSerializer().create(mov_data) for mov_data in movements_data ] validated_data['date_'] = validated_data.pop('date') return TransactionFactory()(**validated_data) def update(self, instance: Transaction, validated_data): if 'date' in validated_data: instance.set_date(validated_data['date']) if 'get_movements_specs' in validated_data: movements_data = validated_data.pop('get_movements_specs') movements = [ MovementSpecSerializer().create(mov_data) for mov_data in movements_data ] instance.set_movements(movements) if 'description' in validated_data: instance.set_description(validated_data['description']) return instance
class RuleSerializer(serializers.ModelSerializer): conditions = ConditionSerializer(many=True, required=False) rules = ListSerializer(child=RecursiveField(), required=False) class Meta: model = models.SegmentRule fields = ("type", "rules", "conditions")
def get(self, request, format=None): """ Return a list of all users. """ stock = request.query_params.get('stock') data_length = request.query_params.get('data-length') data_type = request.query_params.get('data-type') algorithm = request.query_params.get('algorithm') results = Result.objects.filter(stock=stock) if data_length: results = results.filter(data_length=int(data_length)) if data_type: results = results.filter(data_type=data_type) if algorithm == 'svm': gamma = request.query_params.get('gamma') c = request.query_params.get('c') coef0 = request.query_params.get('coef0') kernel = request.query_params.get('kernel') if gamma: results = results.filter(algorithm__svm__gamma=float(gamma)) if c: results = results.filter(algorithm__svm__c=float(c)) if coef0: results = results.filter(algorithm__svm__coef0=float(coef0)) if kernel: results = results.filter(algorithm__svm__kernel=kernel) else: print('not found') return Response(status=404) print('returning response') return Response( ListSerializer(results.all(), child=ResultSerializer()).data)
class RegisterEmployeesSerializer(Serializer): """Serializer to register a set of user's.""" update = None create = None members = ListSerializer(child=EmailField()) company = PrimaryKeyRelatedField(queryset=Company.objects.all()) def save(self, **kwargs): """ Create accounts for all the user's that are registered. :param kwargs: Additional creation kwargs (ignored) :type kwargs: any :return: The number of send emails :rtype: int """ group = Group.objects.get(id=Groups.employee) company = self.validated_data["company"] members = self.validated_data["members"] transport = MultiMailTransport({"company": company.name}, 1, company) seeder = (transport(*self.employ(a, company, group)) for a in members) return transport.finish(seeder) @staticmethod def employ(account, company, group): """ Create and initialize a single employee. :param company: The company to employ the user for :type company: companies.models.Company :param account: The email address to create the account for :type account: str :param group: The group to assign the user to :type group: django.contrib.models.Group :return: The parameters to the transport :rtype: tuple """ password = User.objects.make_random_password(12) instance = User.objects.create_user(email=account, password=password) receiver = instance.email instance.group = group instance.member.create(company=company) return receiver, {"email": receiver, "password": password}
class RentSerializer(EnumSupportSerializerMixin, FieldPermissionsSerializerMixin, serializers.ModelSerializer): id = serializers.IntegerField(required=False) due_dates = RentDueDateSerializer(many=True, required=False, allow_null=True) fixed_initial_year_rents = FixedInitialYearRentSerializer(many=True, required=False, allow_null=True) contract_rents = ContractRentSerializer(many=True, required=False, allow_null=True) index_adjusted_rents = IndexAdjustedRentSerializer(many=True, required=False, allow_null=True, read_only=True) rent_adjustments = RentAdjustmentSerializer(many=True, required=False, allow_null=True) payable_rents = PayableRentSerializer(many=True, required=False, allow_null=True, read_only=True) equalized_rents = EqualizedRentSerializer(many=True, required=False, allow_null=True, read_only=True) yearly_due_dates = ListSerializer(child=DayMonthField(read_only=True), source='get_due_dates_as_daymonths', read_only=True) class Meta: model = Rent fields = ('id', 'type', 'cycle', 'index_type', 'due_dates_type', 'due_dates_per_year', 'elementary_index', 'index_rounding', 'x_value', 'y_value', 'y_value_start', 'equalization_start_date', 'equalization_end_date', 'amount', 'note', 'due_dates', 'fixed_initial_year_rents', 'contract_rents', 'index_adjusted_rents', 'rent_adjustments', 'payable_rents', 'equalized_rents', 'start_date', 'end_date', 'yearly_due_dates', 'seasonal_start_day', 'seasonal_start_month', 'seasonal_end_day', 'seasonal_end_month', 'manual_ratio', 'manual_ratio_previous') def override_permission_check_field_name(self, field_name): if field_name == 'yearly_due_dates': return 'due_dates' return field_name
def react_user_list(users, project, identifier): users = users.order_by(Lower('username')) user_list = ListSerializer(users, child=UserWithMailSerializer()).data format_strings = { 'users': json.dumps(user_list), 'project': project.pk, 'listen_to': identifier, } return format_html(('<span data-euth-widget="userlist"' ' data-users="{users}"' ' data-project="{project}"' ' data-listen-to="{listen_to}"></span>'), **format_strings)
def __init__(self, *args, **kwargs): """ Override init to add in the object serializer field on-the-fly. """ super(ContextPassingPaginationSerializer, self).__init__(*args, **kwargs) results_field = self.results_field try: object_serializer = self.Meta.object_serializer_class except AttributeError: object_serializer = DefaultObjectSerializer self.fields[results_field] = ListSerializer( child=object_serializer(context=kwargs["context"]), source='object_list')
def many_init(cls, *args, **kwargs): """ This method implements the creation of a `ListSerializer` parent class when `many=True` is used. You can customize it if you need to control which keyword arguments are passed to the parent, and which are passed to the child. Note that we're over-cautious in passing most arguments to both parent and child classes in order to try to cover the general case. If you're overriding this method you'll probably want something much simpler, eg: @classmethod def many_init(cls, *args, **kwargs): kwargs['child'] = cls() return CustomListSerializer(*args, **kwargs) """ kwargs['child'] = BasePageSerializer(*args, **kwargs) return ListSerializer(*args, **kwargs)
class GroupSerializer(ModelSerializer): """Group Serializer""" attributes = JSONField(validators=[is_dict], required=False) users_obj = ListSerializer(child=GroupMemberSerializer(), read_only=True, source="users", required=False) parent_name = CharField(source="parent.name", read_only=True) class Meta: model = Group fields = [ "pk", "name", "is_superuser", "parent", "parent_name", "users", "attributes", "users_obj", ]
class UserSerializer(ModelSerializer): """User Serializer""" is_superuser = BooleanField(read_only=True) avatar = CharField(read_only=True) attributes = JSONField(validators=[is_dict], required=False) groups = PrimaryKeyRelatedField(allow_empty=True, many=True, source="ak_groups", queryset=Group.objects.all()) groups_obj = ListSerializer(child=GroupSerializer(), read_only=True, source="ak_groups") uid = CharField(read_only=True) class Meta: model = User fields = [ "pk", "username", "name", "is_active", "last_login", "is_superuser", "groups", "groups_obj", "email", "avatar", "attributes", "uid", ] extra_kwargs = { "name": { "allow_blank": True }, }
def get_non_deleted(self,user): qs = List.objects.filter(is_deleted=False).filter(Q(owner=user)|Q(shared_with=user)) lists = ListSerializer(instance=qs,many=True) return lists.data
def make_list(self, data_list, serializer): list_serializer = ListSerializer(child=serializer) return ReturnList(data_list, serializer=list_serializer)
class Answer(Serializer): """User's Choice serializer.""" user_id = IntegerField() answers = ListSerializer(child=JSONField(), allow_empty=False) class Meta: fields = 'user_id', 'answers' def validate_user_id(self, value): poll = self.context['poll'] if models.Answer.objects.filter(user_id=value, poll=poll).exists(): raise ValidationError("You've already answered this poll.") return value def validate_answers(self, value): if not value: raise ValidationError("Please, provide some answers.") poll = self.context['poll'] questions = {q.id: q for q in poll.questions.all()} valid_answers = [] found_answers = set() for raw_answer in value: if not (question := questions.get(raw_answer.get('question_id'), None)): continue choice = raw_answer.get('choice') question_type = QType(question.q_type) if question_type != QType.MANY and question.id in found_answers: raise ValidationError( f"Only single choice allowed for question id {question.id}" ) found_answers.add(question.id) if question_type == QType.ARBITRARY: if not isinstance(choice, str): raise ValidationError( "Answer to question of this type must be a string.") valid_answers.append(raw_answer) continue if not isinstance(choice, int): raise ValidationError( f"Answer to question id {question.id} must be an integer id of a choice." ) try: existing_choice = models.Choice.objects.get(id=choice) except models.Choice.DoesNotExist as e: raise ValidationError(f"Choice id {choice} not found.") from e if existing_choice.question != question: raise ValidationError( f"Choice id {choice} is for anoher question.") valid_answers.append(raw_answer) if len(found_answers) != len(questions): raise ValidationError( f"Please, provide answers to questions: {list(questions)}.") return valid_answers
class BaseListSerializer(Serializer): data = ListSerializer( required=False, allow_empty=True, child=BaseSerializer(required=False, allow_null=True), )
class UserSelfSerializer(ModelSerializer): """User Serializer for information a user can retrieve about themselves and update about themselves""" is_superuser = BooleanField(read_only=True) avatar = CharField(read_only=True) groups = SerializerMethodField() uid = CharField(read_only=True) settings = DictField(source="attributes.settings", default=dict) @extend_schema_field( ListSerializer(child=inline_serializer( "UserSelfGroups", { "name": CharField(read_only=True), "pk": CharField(read_only=True) }, ))) def get_groups(self, _: User): """Return only the group names a user is member of""" for group in self.instance.ak_groups.all(): yield { "name": group.name, "pk": group.pk, } def validate_email(self, email: str): """Check if the user is allowed to change their email""" if self.instance.group_attributes().get( USER_ATTRIBUTE_CHANGE_EMAIL, CONFIG.y_bool("default_user_change_email", True)): return email if email != self.instance.email: raise ValidationError("Not allowed to change email.") return email def validate_name(self, name: str): """Check if the user is allowed to change their name""" if self.instance.group_attributes().get( USER_ATTRIBUTE_CHANGE_NAME, CONFIG.y_bool("default_user_change_name", True)): return name if name != self.instance.name: raise ValidationError("Not allowed to change name.") return name def validate_username(self, username: str): """Check if the user is allowed to change their username""" if self.instance.group_attributes().get( USER_ATTRIBUTE_CHANGE_USERNAME, CONFIG.y_bool("default_user_change_username", True)): return username if username != self.instance.username: raise ValidationError("Not allowed to change username.") return username def save(self, **kwargs): if self.instance: attributes: dict = self.instance.attributes attributes.update(self.validated_data.get("attributes", {})) self.validated_data["attributes"] = attributes return super().save(**kwargs) class Meta: model = User fields = [ "pk", "username", "name", "is_active", "is_superuser", "groups", "email", "avatar", "uid", "settings", ] extra_kwargs = { "is_active": { "read_only": True }, "name": { "allow_blank": True }, }
class RentSerializer( EnumSupportSerializerMixin, FieldPermissionsSerializerMixin, serializers.ModelSerializer, ): id = serializers.IntegerField(required=False) due_dates = RentDueDateSerializer(many=True, required=False, allow_null=True) fixed_initial_year_rents = FixedInitialYearRentSerializer(many=True, required=False, allow_null=True) contract_rents = ContractRentSerializer(many=True, required=False, allow_null=True) index_adjusted_rents = IndexAdjustedRentSerializer(many=True, required=False, allow_null=True, read_only=True) rent_adjustments = RentAdjustmentSerializer(many=True, required=False, allow_null=True) payable_rents = PayableRentSerializer(many=True, required=False, allow_null=True, read_only=True) equalized_rents = EqualizedRentSerializer(many=True, required=False, allow_null=True, read_only=True) yearly_due_dates = ListSerializer( child=DayMonthField(read_only=True), source="get_due_dates_as_daymonths", read_only=True, ) class Meta: model = Rent fields = ( "id", "type", "cycle", "index_type", "due_dates_type", "due_dates_per_year", "elementary_index", "index_rounding", "x_value", "y_value", "y_value_start", "equalization_start_date", "equalization_end_date", "amount", "note", "due_dates", "fixed_initial_year_rents", "contract_rents", "index_adjusted_rents", "rent_adjustments", "payable_rents", "equalized_rents", "start_date", "end_date", "yearly_due_dates", "seasonal_start_day", "seasonal_start_month", "seasonal_end_day", "seasonal_end_month", "manual_ratio", "manual_ratio_previous", ) def override_permission_check_field_name(self, field_name): if field_name == "yearly_due_dates": return "due_dates" return field_name
def many_init(cls, *args, **kwargs): kwargs['child'] = PageSerializer(*args, **kwargs) return ListSerializer(*args, **kwargs)