class AuditedEntitySerializer(serializers.ModelSerializer):
created_at = serializers.DateTimeField(
default=serializers.CreateOnlyDefault(timezone.now))
updated_at = serializers.DateTimeField(default=timezone.now)
created_by = serializers.IntegerField(
default=serializers.CreateOnlyDefault(CurrentUserDefault()))
updated_by = serializers.IntegerField(default=CurrentUserDefault())
class TeamMembershipModifySerializer(serializers.ModelSerializer):
"""Serializer for create, update, delete."""
team = serializers.PrimaryKeyRelatedField(many=False,
queryset=Team.objects.all())
member = serializers.PrimaryKeyRelatedField(many=False,
queryset=User.objects.all())
id = serializers.IntegerField(required=False, read_only=True)
added_date = serializers.DateTimeField(
required=False, default=serializers.CreateOnlyDefault(timezone.now))
is_owner = serializers.BooleanField(
required=False, default=serializers.CreateOnlyDefault(False))
can_edit = serializers.BooleanField(
required=False, default=serializers.CreateOnlyDefault(True))
def validate(self, data):
"""Make sure we do not already have an owner."""
if "is_owner" in data and data["is_owner"]:
current_owner = TeamMembership.objects.filter(
team=data["team"], is_owner=True).first()
if current_owner is not None:
raise ValidationError("teams can only have one owner")
return data
class Meta:
"""Meta data related to the Team Membership Modification serializer."""
model = TeamMembership
fields = ('id', 'added_date', 'is_owner', 'can_edit', 'member', 'team')
class BaseLogSerializer(serializers.ModelSerializer):
timestamp = serializers.DateTimeField(default=serializers.CreateOnlyDefault(tz.now))
type = serializers.CharField(default=serializers.CreateOnlyDefault('GENERAL'))
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
company = serializers.HiddenField(default=serializers.CreateOnlyDefault(CompanyDefault()))
class Meta:
model = Log
depth = 1
fields = ('id', 'message', 'timestamp', 'user', 'type', 'company')
class InvoiceLogSerializer(BaseLogSerializer):
invoice = serializers.HiddenField(
default=serializers.CreateOnlyDefault(DefaultInvoice()))
type = serializers.CharField(
default=serializers.CreateOnlyDefault('INVOICE'))
class Meta:
model = InvoiceLog
depth = 1
fields = ('message', 'timestamp', 'user', 'company', 'type', 'invoice')
class JournalEntryCreateSerializer(serializers.ModelSerializer):
"""Serializer for create JournalEntry."""
timestamp_come = serializers.HiddenField(
default=serializers.CreateOnlyDefault(get_now_time))
datestamp = serializers.HiddenField(
default=serializers.CreateOnlyDefault(get_now_date))
class Meta:
model = JournalEntry
fields = ('id', 'child', 'datestamp', 'timestamp_come', 'people_come')
class AcknowledgementLogSerializer(BaseLogSerializer):
acknowledgement = serializers.HiddenField(
default=serializers.CreateOnlyDefault(DefaultAcknowledgement))
type = serializers.CharField(
default=serializers.CreateOnlyDefault('SALES ORDER'))
class Meta:
model = AckLog
depth = 1
fields = ('message', 'timestamp', 'employee', 'company', 'type',
'acknowledgement')
class GameSerializerWithReadOnlyDimensions(serializers.HyperlinkedModelSerializer):
class Meta:
model = Game
fields = ('id', 'height', 'width', 'start_time', 'end_time', 'client_state', 'game_state', 'bombs')
width = serializers.IntegerField(
read_only=True,
default=serializers.CreateOnlyDefault(8)
)
height = serializers.IntegerField(
read_only=True,
default=serializers.CreateOnlyDefault(8)
)
class UserFavorSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(
default=serializers.CurrentUserDefault(),
queryset=UserProfile.objects.all())
# read-only fields
add_time = serializers.DateTimeField(default=serializers.CreateOnlyDefault(
datetime.now()),
format='%Y-%m-%d %H:%M:%S',
read_only=True)
fav_object = GenericRelatedField({Article: FavorArticleSerializer()},
read_only=True)
# write-only fields
fav_type = serializers.IntegerField(write_only=True, min_value=1)
class Meta:
model = UserFavorite
fields = ('id', 'user', 'add_time', 'fav_object', 'fav_type', 'fav_id')
validators = [
UniqueTogetherValidator(
message="已经收藏",
fields=('user', 'fav_type', 'fav_id'),
queryset=UserFavorite.objects.all().filter(is_valid=True))
]
def create(self, validated_data):
content_type = ContentType_Map.get(validated_data.get("fav_type"))
validated_data.update({"content_type": content_type})
return validated_data
class FaqSerializer(serializers.ModelSerializer):
service_type_cd = serializers.ChoiceField(required=True,
choices=SERVICE_TYPE_CDS,
help_text="서비스 타입 구분")
board_detail_type_cd = serializers.ChoiceField(
required=True,
choices=Faq.BOARD_DETAIL_TYPE_CDS,
help_text="게시판 상세 타입 구분")
created_at = serializers.HiddenField(
default=serializers.CreateOnlyDefault(timezone.now))
updated_at = serializers.HiddenField(default=timezone.now)
created_id = serializers.IntegerField(write_only=True)
class Meta:
model = Faq
fields = ('id', 'service_type_cd', 'board_detail_type_cd', 'question',
'answer', 'is_best', 'created_at', 'updated_at',
'created_id')
extra_kwargs = {
'question': {
'help_text': '제목'
},
'answer': {
'help_text': '내용'
},
'is_best': {
'help_text': 'Best 여부'
},
}
class VersionSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = Version
fields = ['id', 'version', 'name', 'creator']
class CommentSerializer(serializers.ModelSerializer):
content_type = ContentTypeField()
image = VersatileImageFieldSerializer(required=False,
allow_null=True,
sizes='image_size')
user = UserSerializer(read_only=True, many=False)
user_id = serializers.IntegerField(
default=serializers.CreateOnlyDefault(CurrentUserDefault()))
child = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = '__all__'
def get_child(self, obj):
queryset = Comment.objects.filter(object_id=obj.id,
content_type__model='comment')
serializers = CommentSerializer(queryset,
many=True,
context=self.context)
return serializers.data
class AddressSerializer(serializers.ModelSerializer):
user_id = serializers.IntegerField(
default=serializers.CreateOnlyDefault(CurrentUserDefault()))
title = serializers.SerializerMethodField()
class Meta:
model = Address
fields = '__all__'
def get_title(self, obj):
if obj.onMap:
return obj.address
return '%s / %s / %s / %s / %s' % (obj.city, obj.community, obj.street,
obj.building, obj.roomNo)
def update(self, instance, validated_data):
defAddr = validated_data.get('defAddr', None)
if defAddr:
qs = Address.objects.filter(user_id=instance.user_id)
for addr in qs:
addr.defAddr = False
addr.save()
return super().update(instance, validated_data)
class ResourceSerializer(serializers.ModelSerializer):
user_id = serializers.PrimaryKeyRelatedField(
source='user',
queryset=User.objects.all(),
default=serializers.CreateOnlyDefault(serializers.CurrentUserDefault()),
)
@cached_property
def request_user(self) -> User:
return self.context['request'].user
class Meta:
model = Resource
fields = ('id', 'user_id', 'name')
def validate_user_id(self, user: User) -> User:
if self.request_user.is_staff:
return user
return self.request_user
@transaction.atomic()
def create(self, validated_data: Dict[str, Any]) -> Resource:
user = validated_data['user']
quota = UserQuota.objects.select_for_update().get(user=user)
if quota.limit is not None and user.resources.count() >= quota.limit:
raise PermissionDenied(f'Resources quota is exceeded. Current limit is {quota.limit}.')
return super().create(validated_data)
class SendingDomainSerializer(serializers.HyperlinkedModelSerializer):
dkim_status = serializers.ReadOnlyField(allow_null=True)
app_domain_status = serializers.ReadOnlyField(allow_null=True)
_links = HALLinksField(nested_endpoints=['revalidate'],
view_name='domains:sendingdomain-detail')
alt_organizations = AltOrganizationsField(
many=True, view_name='users:organization-detail', required=False)
organization = serializers.HiddenField(
default=serializers.CreateOnlyDefault(CurrentOrganizationDefault()))
class Meta:
model = SendingDomain
fields = [
'url', 'name', 'dkim_status', 'app_domain_status', 'organization',
'alt_organizations', 'app_domain', 'app_domain_status_date',
'dkim_status_date', '_links'
]
read_only_fields = [
'organization', 'dkim_status_date', 'app_domain_status_date'
]
extra_kwargs = {'url': {'view_name': 'domains:sendingdomain-detail'}}
def validate(self, attrs):
for organization in attrs.get('alt_organizations', []):
if organization.parent_id != attrs.get('organization').id:
raise ValidationError('Invalid organization')
return attrs
class LinkSerializer(serializers.HyperlinkedModelSerializer):
url_field_name = "selflink"
class Meta:
model = models.Link
fields = ["selflink", "short", "owner", "target"]
extra_kwargs = {"selflink": {"lookup_field": "short"}}
short = serializers.CharField(
min_length=6,
max_length=32,
default=serializers.CreateOnlyDefault(models.link_default_short),
validators=[validators.UniqueValidator(queryset=models.Link.objects.all())],
)
owner = serializers.SlugRelatedField(read_only=True, slug_field="username")
target = serializers.URLField(max_length=200, required=True)
def save(self, **kwargs):
# set the current user as default owner for all operations but allow explicit overwriting with
# keyword arguments to `save(owner=…)`
kwargs.setdefault("owner", self.context["request"].user)
return super().save(**kwargs)
def validate_short(self, value):
"""
Check that short is not changed on update operations
:param value: The new value
:return: The new value in validated form
"""
is_update = self.instance is not None
if is_update and value != self.instance.short:
raise serializers.ValidationError("field cannot be changed once created")
return value
def setup(self):
default = serializers.CreateOnlyDefault('2001-01-01')
class TestSerializer(serializers.Serializer):
published = serializers.HiddenField(default=default)
text = serializers.CharField()
self.Serializer = TestSerializer
class Meta:
model = models.Blueprint
fields = (
'id',
'url',
'title',
'description',
'create_users',
'stack_count',
'label_list',
'properties',
'host_definitions',
'formula_versions',
'labels',
'export',
'user_permissions',
'group_permissions',
)
extra_kwargs = {
'create_users': {
'default':
serializers.CreateOnlyDefault(
settings.STACKDIO_CONFIG.create_ssh_users)
},
}
class IssueSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CreateOnlyDefault(
serializers.CurrentUserDefault()))
assignee = AssigneeSerializer(read_only=True)
class Meta:
model = Issue
fields = [
"id",
"title",
"description",
"due_date",
"status",
"owner",
"assignee",
"project",
]
extra_kwargs = {
"description": {
"required": False
},
"due_date": {
"required": False
},
"status": {
"required": False
},
}
class CreateMessageSerializer(serializers.ModelSerializer):
default_error_messages = {
'invalid_user': '******',
}
sender = serializers.HiddenField(default=serializers.CreateOnlyDefault(
serializers.CurrentUserDefault()))
thread = serializers.PrimaryKeyRelatedField(queryset=Thread.objects.all(),
write_only=True)
class Meta:
model = Message
fields = (
'text',
'sender',
'thread',
)
def validate(self, attrs):
tr = attrs['thread']
user_id = attrs['sender'].id
if not tr.participants.filter(id=user_id).exists():
self.fail('invalid_user', user_id=user_id)
return attrs
class LikeSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.IntegerField(read_only=True)
user = serializers.HiddenField(
default=serializers.CurrentUserDefault()
)
publication = serializers.PrimaryKeyRelatedField(
required=False, queryset=Publication.objects.all(), allow_null=True)
comment = serializers.PrimaryKeyRelatedField(
required=False, queryset=Comment.objects.all(), allow_null=True)
date = serializers.DateTimeField(read_only=True,
default=serializers.CreateOnlyDefault(
datetime.now)
)
def validate(self, attrs):
if attrs['publication'] is not None and attrs['comment'] is not None:
raise serializers.ValidationError(
'Лайк задан и для публикации, и для комметнария, может быть только один вариант')
if attrs['publication'] is None and attrs['comment'] is None:
raise serializers.ValidationError(
'Лайк не задан ни для публикации, ни для комметнария')
return attrs
class Meta:
model = Like
fields = "__all__"
class NoteSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CreateOnlyDefault(
serializers.CurrentUserDefault()))
edit_access_to = serializers.PrimaryKeyRelatedField(
many=True, queryset=User.objects.all(), required=False)
view_access_to = serializers.PrimaryKeyRelatedField(
many=True, queryset=User.objects.all(), required=False)
def __init__(self, *args, **kwargs):
no_access = kwargs.pop("no_access", False)
super(NoteSerializer, self).__init__(*args, **kwargs)
if no_access:
self.fields.pop("edit_access_to")
self.fields.pop("view_access_to")
class Meta:
model = Note
fields = [
"id",
"content",
"createdon",
"modifiedon",
"owner",
"edit_access_to",
"view_access_to",
]
class GroupSerializer(serializers.ModelSerializer):
store = serializers.PrimaryKeyRelatedField(
write_only=True,
queryset=Store.objects.all(),
default=serializers.CreateOnlyDefault(
RequestAttributeDefault(
attribute='user.staff.store'
)
)
)
class Meta:
model = Group
fields = (
'id',
'name',
'description',
'email',
'delivery',
'payment_online_only',
'deadline',
'delay',
'discount',
'store',
)
read_only_fields = (
'id',
)
class ContractSerializer(serializers.ModelSerializer):
user_id = serializers.IntegerField(
default=serializers.CreateOnlyDefault(CurrentUserDefault()))
contractID = serializers.SerializerMethodField()
validity = serializers.SerializerMethodField()
visits = serializers.SerializerMethodField()
class Meta:
model = Contract
fields = '__all__'
def get_contractID(self, obj):
return obj.contractID
def get_validity(self, obj):
return timezone.now().strftime('%Y-%m-%d') >= obj.issue_date.strftime(
'%Y-%m-%d') and timezone.now().strftime(
'%Y-%m-%d') <= obj.expiry_date.strftime('%Y-%m-%d')
def get_visits(self, obj):
query = obj.order.all().values('service').annotate(
count=Count('service'))
serializer = VisitSerializer(instance=query, many=True)
return serializer.data
class ProductVersionSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = ProductVersion
# 逆参照のrelated_name=vulnerabilityをfieldsに入れる
fields = ['id', 'name', 'version', 'creator', 'created_at', 'vulnerability']
class ProductSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
# 対象のモデル
model = Product
# 利用するフィールド
fields = ['id', 'name', 'part', 'vendor', 'url', 'creator']
class NotesSerializer(serializers.ModelSerializer):
# user = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault())
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
created = serializers.DateTimeField(
default=serializers.CreateOnlyDefault(timezone.now))
class Meta:
model = Notes
fields = ('id', 'user', 'title', 'body', 'created', 'updated')
class LyricSerializer(serializers.HyperlinkedModelSerializer):
created_at = serializers.ReadOnlyField(default=serializers.CreateOnlyDefault(timezone.now))
editor = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault())
previous = serializers.HyperlinkedRelatedField(read_only=True, view_name='lyricrevision-detail')
next = serializers.HyperlinkedRelatedField(read_only=True, view_name='lyricrevision-detail')
class Meta:
model = LyricRevision
fields = ('url', 'id', 'song', 'lyrics', 'previous', 'next', 'created_at', 'editor')
class PlaylistSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CreateOnlyDefault(
serializers.CurrentUserDefault()))
owner_name = serializers.CharField(source='owner.username', read_only=True)
musics = serializers.PrimaryKeyRelatedField(queryset=Music.objects,
many=True)
class Meta:
model = Playlist
fields = '__all__'
class EventFieldMixin(serializers.Serializer):
recording_date = serializers.ReadOnlyField()
creator = UserSerializer(read_only=True, default=serializers.CreateOnlyDefault(serializers.CurrentUserDefault()))
def add_event_read_only_default_fields(self, validated_data):
# Include default for read_only `creator` field
# for some reason, it is not possible to have read only and default value https://www.django-rest-framework.org/community/release-notes/#380
# https://stackoverflow.com/questions/35518273/how-to-set-current-user-to-user-field-in-django-rest-framework
#print(self.fields["creator"].get_default())
validated_data["creator"] = self.fields["creator"].get_default()
class ReportSerializer(serializers.ModelSerializer):
author = serializers.SlugRelatedField(slug_field='username', read_only=True,
default=serializers.CurrentUserDefault())
label = CreatableSlugRelatedField(slug_field='label_name', many=True, required=False,
queryset=Label.objects.all())
ntime = serializers.DateTimeField(default=serializers.CreateOnlyDefault(timezone.now()))
class Meta:
model = Report
fields = ('id', 'title', 'envs', 'author', 'introduction', 'label', 'ntime', 'mtime', 'result', 'subroutines')
