class TransactionSerializer(ModelSerializer):
account = AccountPrimaryKeyRelatedField(allow_null=True,
queryset=Account.objects,
required=False)
budget = BudgetPrimaryKeyRelatedField(queryset=Budget.objects,
required=False)
transaction_location = TransactionLocationSerializer(allow_null=True,
required=False)
user = PrimaryKeyRelatedField(queryset=CurrentUserDefault(),
write_only=True,
default=CurrentUserDefault())
class Meta:
model = Transaction
fields = (
"id",
"amount_cents",
"currency",
"date",
"description",
"name",
"origin",
"origin_id",
"account",
"budget",
"transaction_location",
"user",
)
class BudgetSerializer(DynamicFieldsModelSerializer):
user = PrimaryKeyRelatedField(queryset=CurrentUserDefault(),
write_only=True,
default=CurrentUserDefault())
class Meta:
model = Budget
fields = ("id", "amount_cents", "description", "name", "user",
"date_created")
class MeetupModelSerializer(ModelSerializer):
user = PrimaryKeyRelatedField(default=CurrentUserDefault(), read_only=True)
questions = SerializerMethodField()
class Meta:
model = Meetup
fields = [
'id',
'user',
'title',
'description',
'date',
'time',
'venue',
'questions',
'created_at',
'updated_at',
]
read_only_fields = (
'id',
'time',
'created_at',
'updated_at',
)
def get_questions(self, obj):
question = Question.objects.filter(meetup=obj)
return QuestionModelSerializer(question, many=True).data
class GymClassListSerializer(ModelSerializer):
trainer = StringRelatedField(default=CurrentUserDefault())
attendees = StringRelatedField(many=True, read_only=True)
class Meta:
model = GymClass
fields = "__all__"
class FileSerializer(ModelSerializer):
name = CharField(max_length=300)
photo = ImageField(required=False)
is_public = BooleanField(required=False)
delete_date = DateField(required=False)
# read_only
pk = IntegerField(read_only=True)
issue_date = DateTimeField(read_only=True)
update_date = DateTimeField(read_only=True)
file_user = DictField(read_only=True, source="user_as_dict")
file_parents = ListField(read_only=True, source="parents_as_list")
file_children = ListField(read_only=True, source="children_as_list")
# A `HiddenField` does not take input from the user, or present any output
fk_user = HiddenField(default=CurrentUserDefault())
class Meta:
model = FileModel
fields = (
"pk",
"fk_parent",
"name",
"photo",
"is_public",
"issue_date",
"update_date",
"delete_date",
"file_user",
"file_parents",
"file_children",
"fk_user",
)
class ProjectSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta:
model = Project
fields = ('name', 'slug', 'created', 'updated', 'website',
'description', 'logo', 'owner')
class UserSurveySerializer(ModelSerializer):
class Meta:
model = UserSurvey
fields = (
'user',
'contribution_level',
'phone',
'preferred_contact',
'year_began',
'organization',
'total_colonies',
'relocate',
'income',
'practice',
'varroa_management',
'varroa_management_trigger',
'purchased_queens',
'purchased_queens_sources',
'resistant_queens',
'resistant_queens_genetics',
'rear_queens',
'equipment',
)
user = PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
class PlacesSerializer(GeoModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
model = Places
geo_field = "coordinates"
fields = ("id", "title", "description", "coordinates", "user")
class TimerSerializer(BaseModelSerializer):
owner = PrimaryKeyRelatedField(read_only=True,
default=CurrentUserDefault())
elapsed = SerializerMethodField(read_only=True)
def get_elapsed(self, timer):
if get_db_name(timer) != 'sqlite3':
# Aggregating datetime fields doesn't work on sqlite, as the values are stored as text.
return timer.durations.annotate(elapsed=F('end') -
F('start')).aggregate(
elapsed=Sum('elapsed'))
total = 0
for duration in timer.durations.all():
end = duration.end
if not end:
end = timezone.now()
total = total + (end - duration.start).total_seconds()
return total
def validate(self, data):
if self.request.user.is_superuser:
if not 'owner' in data:
data['owner'] = self.request.user
else:
data['owner'] = self.request.user
return data
class Meta:
model = Timer
fields = ('id', 'name', 'description', 'owner', 'countdowns',
'durations', 'elapsed')
unique_together = ('name', 'owner')
class CheckSerializer(HyperlinkedModelSerializer):
url = CheckHyperlinkedIdentityField('api-check-detail')
patch = HiddenField(default=CurrentPatchDefault())
user = UserSerializer(default=CurrentUserDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
# NOTE(stephenfin): 'data' is essentially 'request.POST', which
# is immutable by default. However, there's no good reason for
# this to be this way [1], so temporarily unset that mutability
# to fix what we need to here.
#
# [1] http://stackoverflow.com/a/12619745/613428
mutable = data._mutable # noqa
data._mutable = True # noqa
data['state'] = val
data._mutable = mutable # noqa
break
return super(CheckSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(CheckSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
return data
class Meta:
model = Check
fields = ('id', 'url', 'patch', 'user', 'date', 'state', 'target_url',
'context', 'description')
read_only_fields = ('date',)
extra_kwargs = {
'url': {'view_name': 'api-check-detail'},
}
class MessageQueueSerializer(BulkSerializerMixin, serializers.ModelSerializer):
user = PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
class Meta:
model = MessageQueue
exclude = ('id', 'user', 'created_on')
list_serializer_class = BulkListSerializer
class LessonSerializer(TaggitSerializer, ModelSerializer):
"""
Store and retrieve Lessons
"""
tags = TagListSerializerField()
queueItems = SerializerMethodField()
creator = PrimaryKeyRelatedField(
# set it to read_only as we're handling the writing part ourselves
read_only=True,
default=CurrentUserDefault())
class Meta:
"""
A meta class to specify our model, fields and ordering
"""
model = Lesson
fields = [
'id', 'name', 'created', 'creator', 'level', 'description',
'notes', 'queueItems', 'tags'
]
ordering = ['-id']
def get_queueItems(self, instance):
"""
Override get_() to order by rank
"""
queueItems = instance.queueItems.all().order_by('rank')
return QueueItemSerializer(queueItems, many=True).data
class ManualDataUploadSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
import_batch = ImportBatchSerializer(read_only=True)
can_edit = BooleanField(read_only=True)
class Meta:
model = ManualDataUpload
fields = ('pk', 'report_type', 'organization', 'platform', 'data_file',
'user', 'created', 'is_processed', 'log', 'import_batch',
'extra', 'can_edit', 'owner_level')
def validate(self, attrs):
attrs = super().validate(attrs)
return attrs
def update(self, instance: ManualDataUpload, validated_data):
result = super().update(instance, validated_data) # type: Annotation
return self._adjust_permissions(result)
def create(self, validated_data):
result = super().create(validated_data)
return self._adjust_permissions(result)
@classmethod
def _adjust_permissions(cls, instance: ManualDataUpload):
if instance.user:
instance.owner_level = \
instance.user.organization_relationship(instance.organization_id)
# we do not want to set the level too high in order for the staff to be able to edit it
if instance.owner_level > UL_CONS_STAFF:
instance.owner_level = UL_CONS_STAFF
instance.save()
return instance
class FeedSerializer(ModelSerializer):
links = FeedLinkSerializer(many=True, read_only=True)
count = SerializerMethodField()
position = IntegerField(read_only=True)
user = HiddenField(default=CurrentUserDefault())
favIcon = CharField(default='undefined', required=False)
class Meta:
model = Feed
def create(self, validated_data):
position = len(Feed.objects.filter(user=validated_data['user']))
validated_data['position'] = position
feed = super().create(validated_data)
link_serializer = LinkSerializer(data=self.initial_data)
link_serializer.is_valid()
link = link_serializer.save()
feedlink_serializer = FeedLinkSerializer(
data={
'feed': feed.pk,
'link': link,
'reg_exp': self.initial_data.get('regExp', '')
})
feedlink_serializer.is_valid()
feedlink_serializer.save()
return feed
def get_count(self, obj):
return len(Post.objects.filter(feed=obj, view=False))
class BudgetTypeSerializer(ModelSerializer):
creator = PrimaryKeyRelatedField(queryset=User.objects.all(),
default=CurrentUserDefault())
class Meta:
model = BudgetType
fields = '__all__'
class ChecksSerializer(ModelSerializer):
user = HyperlinkedRelatedField('user-detail',
read_only=True,
default=CurrentUserDefault())
patch = HiddenField(default=CurrentPatchDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
data['state'] = val
break
return super(ChecksSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(ChecksSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
# drf-nested doesn't handle HyperlinkedModelSerializers properly,
# so we have to put the url in by hand here.
url = self.context['request'].build_absolute_uri(
reverse('api_1.0:patch-detail', args=[instance.patch.id]))
data['url'] = url + 'checks/%s/' % instance.id
data['users_url'] = data.pop('user')
return data
class Meta:
model = Check
read_only_fields = ('date', )
class TrainingGameCreateSerializer(HyperlinkedModelSerializer):
"""
TrainingGameCreateSerializer serialize a new game adding the current user as submitter
"""
# https://www.django-rest-framework.org/api-guide/validators/#advanced-field-defaults
submitted_by = HiddenField(default=CurrentUserDefault())
class Meta:
model = TrainingGame
fields = [
"url",
"id",
"run",
"created_at",
"submitted_by",
"board_size_x",
"board_size_y",
"handicap",
"komi",
"gametype",
"rules",
"extra_metadata",
"winner",
"score",
"resigned",
"game_length",
"white_network",
"black_network",
"sgf_file",
"training_data_file",
"num_training_rows",
"kg_game_uid",
]
extra_kwargs = {
"run": {
"lookup_field": "name"
},
"white_network": {
"lookup_field": "name"
},
"black_network": {
"lookup_field": "name"
},
}
def validate(self, data):
validate_game_npzdata(data["training_data_file"], data["run"])
if not data["white_network"].training_games_enabled or not data[
"black_network"].training_games_enabled:
raise ValidationError(
"Network is no longer enabled for training games")
if data["run"].status != Run.RunStatus.ACTIVE:
raise ValidationError("Run is not active")
if not data["submitted_by"]:
raise ValidationError("Unknown user")
if not data["run"].is_allowed_username(data["submitted_by"].username):
raise ValidationError(
"Run is currently closed except for private testing")
return data
class ContactSerializer(BulkSerializerMixin, serializers.ModelSerializer):
user = PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
queue_number = serializers.CharField(source="queue.number")
class Meta:
model = Contact
exclude = ('id', 'user', 'queue')
list_serializer_class = BulkListSerializer
def create(self, validated_data):
message_queue = validated_data.pop('queue')["number"]
validated_data["queue"] = MessageQueue.objects.get(
number=message_queue)
number = validated_data.pop('contact')
#Check if exist:
contact = Contact.objects.filter(contact=number)
if contact:
contact = contact.first()
contact.queue = validated_data["queue"]
contact.status = validated_data["status"]
contact.save()
return contact
validated_data["contact"] = number
contact = Contact.objects.create(**validated_data)
contact.save()
return contact
class FollowSerializer(CurrentUserDefault, ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
fields = ('author', 'user')
model = Follow
validators = (validate_author, )
class CheckSerializer(HyperlinkedModelSerializer):
url = CheckHyperlinkedIdentityField('api-check-detail')
patch = HiddenField(default=CurrentPatchDefault())
user = UserSerializer(read_only=True, default=CurrentUserDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
data['state'] = val
break
return super(CheckSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(CheckSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
return data
class Meta:
model = Check
fields = ('id', 'url', 'patch', 'user', 'date', 'state', 'target_url',
'context', 'description')
read_only_fields = ('date', )
extra_kwargs = {
'url': {
'view_name': 'api-check-detail'
},
}
class FundingCapitalSerializer(BulkSerializerMixin,serializers.ModelSerializer):
user = PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
class Meta:
model = FundingCapital
exclude = ('id', 'user')
list_serializer_class = BulkListSerializer
class RecipeListSerializer(ModelSerializer):
"""
Main GET LIST Serializer for Recipes without all the details
"""
comment_count = IntegerField(read_only=True)
ingredients = QuantityIngredientSerializer(source='quantity_set',
many=True,
read_only=True)
slug = CharField(read_only=True)
tags = TagSerializer(many=True)
added_by = NestedUserSerializer(read_only=True,
default=CreateOnlyDefault(
CurrentUserDefault()))
class Meta:
model = Recipe
fields = (
'id',
'slug',
'name',
'created',
'added_by',
'ingredients',
'comment_count',
'tags',
)
@staticmethod
def setup_eager_loading(queryset):
"Perform necessary eager loading of data."
queryset = queryset.select_related('added_by')
queryset = queryset.prefetch_related('tags', 'quantity_set',
'quantity_set__ingredient')
return queryset
class IncomeCategorySerializer(ModelSerializer):
creator = PrimaryKeyRelatedField(queryset=User.objects.all(),
default=CurrentUserDefault())
class Meta:
model = IncomeCategory
fields = '__all__'
class UserRecompensasSerializer(BulkSerializerMixin,serializers.ModelSerializer):
user = PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
class Meta:
model = UserDonation
exclude = ('id', 'user')
list_serializer_class = BulkListSerializer
class CommentSerializer(ModelSerializer):
user = NestedUserSerializer(
read_only=True,
default=CreateOnlyDefault(CurrentUserDefault()),
)
recipe = NestedRecipeListSerializer()
class Meta:
model = Comment
fields = (
'id',
'user',
'recipe',
'text',
'updated',
'created',
)
validators = [
UniqueTogetherValidator(queryset=Comment.objects.all(),
fields=('user', 'recipe'))
]
@staticmethod
def setup_eager_loading(queryset):
"Perform necessary eager loading of data."
queryset = queryset.select_related('recipe', 'recipe__added_by')
queryset = queryset.prefetch_related(
'recipe__quantity_set', 'recipe__quantity_set__ingredient')
return queryset
class StationSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta:
model = Station
fields = (
'id',
'name',
'created',
'updated',
'type',
'notes',
'is_in_test_mode',
'altitude',
'position',
'country',
'state',
'county',
'community',
'city',
'district',
'owner',
'project',
'last_metering',
)
class TweetSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
fields = (
'id', 'tweet_content', 'writed_at', 'user', 'status') # detay ve listelemelerde gözükecek property'ler
model = Tweet
def validate(self, attrs):
if len(attrs['tweet_content']) > 150:
raise ValidationError("Tweet content very long")
elif len(attrs['tweet_content']) < 3:
raise ValidationError("Tweet content very short")
return attrs
def create(self, validated_data):
tweet = Tweet.objects.create(**validated_data)
tweet.save()
return tweet
def update(self, instance, validated_data):
# kwargs["user"] = self.fields["user"].get_default()
instance.tweet_content = validated_data.get('tweet_content', instance.tweet_content)
instance.status = validated_data.get('status', instance.status)
instance.save()
return instance
class GymClassCreateSerializer(ModelSerializer):
# category = PrimaryKeyRelatedField(read_only=True)
trainer = StringRelatedField(default=CurrentUserDefault())
attendees = StringRelatedField(many=True, read_only=True)
class Meta:
model = GymClass
fields = "__all__"
class Meta:
model = LegalPosition
fields = "__all__"
extra_kwargs = {
'client': {
'default': CreateOnlyDefault(CurrentUserDefault()),
}
}
class Meta:
model = DocumentUpload
exclude = ('upload_datetime', )
extra_kwargs = {
'client': {
'default': CreateOnlyDefault(CurrentUserDefault()),
}
}
