class PostDetailSerializers(ModelSerializer):
created_date = DateTimeField(format="%Y-%m-%d %H:%M:%S")
update_date = DateTimeField(format="%Y-%m-%d %H:%M:%S")
class Meta:
model = Post
fields = ('__all__')
class AbstractReportSliceSerializer(ModelSerializer):
"""Abstract serializer for the ReportSlice models."""
report_platform_id = UUIDField(format='hex_verbose', required=False)
report_slice_id = UUIDField(format='hex_verbose', required=False)
account = CharField(max_length=50, required=False)
report_json = JSONField(allow_null=False)
git_commit = CharField(max_length=50, required=False)
source = CharField(max_length=15, required=True)
source_metadata = JSONField(allow_null=True, required=False)
state = ChoiceField(choices=ReportSlice.STATE_CHOICES)
retry_type = ChoiceField(choices=ReportSlice.RETRY_CHOICES,
default=ReportSlice.TIME)
state_info = JSONField(allow_null=False)
retry_count = IntegerField(default=0)
hosts_count = IntegerField(min_value=1, max_value=MAX_HOSTS_PER_REP)
last_update_time = DateTimeField(allow_null=False)
failed_hosts = JSONField(allow_null=True)
candidate_hosts = JSONField(allow_null=True)
ready_to_archive = BooleanField(default=False)
creation_time = DateTimeField(allow_null=False)
processing_start_time = DateTimeField(allow_null=True, required=False)
processing_end_time = DateTimeField(allow_null=True, required=False)
class Meta:
"""Meta class for AbstractReportSliceSerializer."""
abstract = True
fields = '__all__'
class AbstractReportSerializer(ModelSerializer):
"""Abstract serializer for the Report models."""
report_platform_id = UUIDField(format='hex_verbose', required=False)
host_inventory_api_version = CharField(max_length=10, required=False)
source = CharField(max_length=15, required=False)
source_metadata = JSONField(allow_null=True, required=False)
account = CharField(max_length=50, required=False)
request_id = CharField(max_length=50, required=False)
upload_ack_status = CharField(max_length=10, required=False)
upload_srv_kafka_msg = JSONField(required=True)
git_commit = CharField(max_length=50, required=False)
state = ChoiceField(choices=Report.STATE_CHOICES)
retry_type = ChoiceField(choices=Report.RETRY_CHOICES, default=Report.TIME)
state_info = JSONField(allow_null=True)
retry_count = IntegerField(default=0)
last_update_time = DateTimeField(allow_null=True)
ready_to_archive = BooleanField(default=False)
arrival_time = DateTimeField(allow_null=False)
processing_start_time = DateTimeField(allow_null=True, required=False)
processing_end_time = DateTimeField(allow_null=True, required=False)
class Meta:
"""Meta class for ReportSerializer."""
abstract = True
fields = '__all__'
class ScanTaskSerializer(NotEmptySerializer):
"""Serializer for the ScanTask model."""
source = SourceField(queryset=Source.objects.all())
scan_type = ChoiceField(required=False, choices=ScanTask.SCAN_TYPE_CHOICES)
status = ChoiceField(required=False, read_only=True,
choices=ScanTask.STATUS_CHOICES)
status_message = CharField(required=False, max_length=256)
systems_count = IntegerField(required=False, min_value=0, read_only=True)
systems_scanned = IntegerField(required=False, min_value=0, read_only=True)
systems_failed = IntegerField(required=False, min_value=0, read_only=True)
start_time = DateTimeField(required=False, read_only=True)
end_time = DateTimeField(required=False, read_only=True)
class Meta:
"""Metadata for serializer."""
model = ScanTask
fields = ['source', 'scan_type', 'status', 'status_message',
'systems_count', 'systems_scanned',
'systems_failed', 'start_time', 'end_time']
@staticmethod
def validate_source(source):
"""Make sure the source is present."""
if not source:
raise ValidationError(_(messages.ST_REQ_SOURCE))
return source
class ScanJobSerializer(NotEmptySerializer):
"""Serializer for the ScanJob model."""
scan = ScanField(required=True, many=False, queryset=Scan.objects.all())
sources = SourceField(many=True, read_only=True)
scan_type = ValidStringChoiceField(read_only=True,
choices=ScanTask.SCAN_TYPE_CHOICES)
status = ValidStringChoiceField(read_only=True,
choices=ScanTask.STATUS_CHOICES)
status_message = CharField(read_only=True)
tasks = TaskField(many=True, read_only=True)
options = ScanOptionsSerializer(read_only=True, many=False)
report_id = IntegerField(read_only=True)
start_time = DateTimeField(required=False, read_only=True)
end_time = DateTimeField(required=False, read_only=True)
class Meta:
"""Metadata for serializer."""
model = ScanJob
fields = [
'id', 'scan', 'sources', 'scan_type', 'status', 'status_message',
'tasks', 'options', 'report_id', 'start_time', 'end_time'
]
@staticmethod
def validate_sources(sources):
"""Make sure the source is present."""
if not sources:
raise ValidationError(_(messages.SJ_REQ_SOURCES))
return sources
class GetAliCloundEcsMonitorDataListSerializer(Serializer):
"""
效验获取实例监控数据字段
"""
InstanceID = CharField(required=True)
StartTime = DateTimeField(required=True, format="%Y-%m-%dT%H:%M:%SZ")
EndTime = DateTimeField(required=True, format="%Y-%m-%dT%H:%M:%SZ")
RegionId = CharField(required=False)
Period = ChoiceField(required=False,
choices=(
("60", "60"),
("600", "600"),
("3600", "3600"),
))
currAccount = ChoiceField(
required=False,
choices=tuple(
(k, k) for k, v in settings.ALI_CLOUND_API_ACCOUNT.items()))
def validate(self, data):
if data.get('StartTime') >= data.get("EndTime"):
raise ValidationError("StartTime 要小于 EndTime.")
minutes = int(
(data.get('EndTime') - data.get('StartTime')).seconds / 60)
days = (data.get('EndTime') - data.get('StartTime')).days
if not data.get('Period'):
if days > 2:
data['Period'] = 3600
elif minutes >= 360 or days > 0:
data['Period'] = 600
else:
data['Period'] = 60
return data
class DevUserSerializer(StreamableSerializerMixin, ModelSerializer):
organization = CharField(source='userprofile.organization_name')
user_type = CharField(source='userprofile.user_type')
app_count = IntegerField()
first_active = DateTimeField()
last_active = DateTimeField()
active_app_count = IntegerField()
identification = SerializerMethodField()
class Meta:
model = User
fields = (
'id',
'username',
'email',
'date_joined',
'last_login',
'organization',
'user_type',
'app_count',
'first_active',
'last_active',
'active_app_count',
'identification',
)
def get_identification(self, obj):
identification = UserIdentificationLabel.objects.filter(users=obj.id).values('slug', 'name')
return(list(identification))
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 PostDetailSerializer(ModelSerializer):
create_date = DateTimeField(format='%Y-%m-%d %H:%M:%S.%f')
update_date = DateTimeField(format='%Y-%m-%d %H:%M:%S.%f')
class Meta:
model = Post
fields = ('id', 'title', 'contents', 'create_date', 'update_date')
class SearchSerializer(HaystackSerializer):
id = IntegerField(source="object.id")
source_id = CharField(source="object.source_id")
type = CharField(source="object.type")
names = TopicNameSerializer(
source="object.get_active_names", many=True)
addresses = TopicAddressSerializer(
source="object.get_active_addresses", many=True)
attributes = TopicAttributeSerializer(
source="object.get_active_attributes", many=True)
credential_set = CredentialSetSerializer(
source="object.foundational_credential.credential_set")
credential_type = CredentialTypeSerializer(
source="object.foundational_credential.credential_type")
inactive = BooleanField(
source="object.foundational_credential.inactive")
revoked = BooleanField(
source="object.foundational_credential.revoked")
effective_date = DateTimeField(
source="object.foundational_credential.effective_date")
revoked_date = DateTimeField(
source="object.foundational_credential.revoked_date")
class Meta:
index_classes = [TopicIndex]
fields = ("id", "source_id", "type", "names", "addresses", "attributes", "credential_set",
"credential_type", "inactive", "revoked", "effective_date", "revoked_date")
# ExactFilter fields
exact_fields = ("topic_issuer_id", "topic_type_id", "topic_credential_type_id")
# StatusFilter fields
status_fields = {"topic_inactive": "false", "topic_revoked": "false"}
# HaystackFilter fields
search_fields = ("score")
class AnswerSerializer(ModelSerializer):
""" Serializer for Answer model """
creation_date = DateTimeField(read_only=True, format="%Y-%m-%d %H:%M:%S")
edit_date = DateTimeField(read_only=True, format="%Y-%m-%d %H:%M:%S")
class Meta:
""" Meta class for answer serializer """
model = Answer
fields = '__all__'
extra_kwargs = {'id': {'read_only': True, 'required': False}}
def __init__(self, *args, **kwargs):
super(AnswerSerializer, self).__init__(*args, **kwargs)
if self.context['request'].method == 'GET':
self.fields['creator'] = PersonSerializer(
read_only=True, context=kwargs['context'])
self.fields['question'] = QuestionSerializer(
read_only=True, context=kwargs['context'])
if self.context['request'].method == 'PATCH':
self.fields['creator'] = PersonSerializer(
context=kwargs['context'])
self.fields['question'] = QuestionSerializer(
context=kwargs['context'])
def update(self, instance, validated_data):
instance.edit_date = timezone.now()
instance.save()
return ModelSerializer.update(self, instance, validated_data)
class VolumeSerializer(ModelSerializer):
# We want to return UTC times by default, not the server timezone
creation_time = DateTimeField(default_timezone=timezone.utc)
edition_time = DateTimeField(default_timezone=timezone.utc)
class Meta:
model = Volume
fields = ('id', 'name', 'comment', 'user', 'editor', 'project',
'creation_time', 'edition_time')
class ResourceSerializer(Serializer):
id = CharField()
title = CharField()
description = CharField()
author = CharField()
links = ResourceLinkSerializer(many=True)
created_at = DateTimeField()
updated_at = DateTimeField()
geom = GeometryField()
class CallRecordSerializer(Serializer):
"""
Serializer that gathers information from Call Start and Call End models.
"""
start = DateTimeField()
end = DateTimeField()
call_id = CharField()
destination = CharField()
duration = DurationField()
price = DecimalField(max_digits=10, decimal_places=2)
class DataSourceSerializer(ModelSerializer):
# We want to return UTC times by default, not the server timezone
creation_time = DateTimeField(default_timezone=timezone.utc)
edition_time = DateTimeField(default_timezone=timezone.utc)
class Meta:
model = DataSource
read_only_fields = ('id', )
fields = ('id', 'user', 'project', 'creation_time', 'edition_time',
'name', 'url', 'source_project_id')
class FKContestSerializer(Serializer):
contest_id = IntegerField()
course_id_id = IntegerField()
publisher_id_id = IntegerField()
title = CharField()
participant_number = IntegerField()
start_time = DateTimeField()
end_time = DateTimeField()
chapter = IntegerField()
description = CharField()
class CuahsiResourceSerializer(ResourceSerializer):
details_url = CharField()
sample_mediums = ListField(child=CharField())
variables = ListField(child=CuahsiVariableSetSerializer())
service_org = CharField()
service_code = CharField()
service_url = CharField()
service_title = CharField()
service_citation = CharField()
begin_date = DateTimeField()
end_date = DateTimeField()
class PointSerializer(ModelSerializer):
# We want to return UTC times by default, not the server timezone
creation_time = DateTimeField(default_timezone=timezone.utc)
edition_time = DateTimeField(default_timezone=timezone.utc)
class Meta:
model = Point
read_only_fields = ('id', )
fields = ('id', 'user', 'project', 'creation_time', 'edition_time',
'editor', 'location_x', 'location_y', 'location_z',
' radius', 'confidence')
class MessageSerializer(ModelSerializer):
"""Deserialize message data"""
created = DateTimeField(format="%d-%m-%Y %H:%M:%S")
modified = DateTimeField(format="%d-%m-%Y %H:%M:%S")
class Meta:
model = Message
fields = [
'id', 'header', 'msg_body', 'is_send', 'is_read', 'created',
'modified'
]
class UserSerializer(DynamicModelSerializer):
password = CharField(required=True, write_only=True)
firstName = CharField(required=False, source='first_name')
lastName = CharField(required=False, source='last_name')
createdAt = DateTimeField(read_only=True, source='date_joined')
lastLogin = DateTimeField(read_only=True, source='last_login')
class Meta:
model = User
name = 'user'
fields = ('id', 'email', 'firstName', 'lastName', 'password',
'createdAt', 'lastLogin')
class VisionSerializer (ManyToNativeMixin, ModelSerializer):
author_details = MinimalTwitterUserSerializer(source='author', read_only=True)
replies = ReplySerializer(many=True, read_only=True)
supporters = MinimalTwitterUserSerializer(many=True, read_only=True)
sharers = PrimaryKeyRelatedField(many=True, read_only=True)
tweet_id = IntegerField(read_only=True)
category = PrimaryKeyRelatedField(required=False)
tweeted_at = DateTimeField(required=False)
created_at = DateTimeField(required=False)
updated_at = DateTimeField(required=False)
class Meta:
model = Vision
exclude = ('tweet',)
def get_twitter_service(self):
return self.context['twitter_service']
def get_requesting_user(self):
return self.context['requesting_user']
def many_to_native(self, many_obj):
many_authors = [v.author for v in many_obj]
many_authors += [r.author for r in chain(*(v.replies.all() for v in many_obj))]
if any(not user.sm_not_found for user in many_authors):
service = self.get_twitter_service()
on_behalf_of = self.get_requesting_user()
# Hit the service so that all the users' info is cached.
service.get_users_info(many_authors, on_behalf_of)
# We don't want to call BaseTwitterInfoSerializer's many_to_native, so
# just skip past it.
return super(VisionSerializer, self).many_to_native(many_obj)
def from_native(self, data, files):
# Validate any uploaded media
media_field = ImageField(required=False)
media_file = files.get('media', None)
try:
media = media_field.from_native(media_file)
except ValidationError as err:
if not hasattr(self, '_errors') or self._errors is None:
self._errors = {}
self._errors['media'] = list(err.messages)
return
# Attach uploaded media, if appropriate
if media and 'media_url' not in data:
data['media_url'] = Vision.upload_photo(media)
return super(VisionSerializer, self).from_native(data, {})
class USGSResourceSerializer(ResourceSerializer):
details_url = CharField()
sample_mediums = ListField(child=CharField())
variables = ListField(child=USGSVariableSetSerializer())
service_org = CharField()
service_orgname = CharField()
service_code = CharField()
service_url = CharField()
monitoring_type = CharField()
provider_name = CharField()
service_title = CharField()
service_citation = CharField()
begin_date = DateTimeField()
end_date = DateTimeField()
class BaseSerializer(DynamicFieldsModelSerializer, ModelSerializer):
"""
Base serializer
"""
creator = UserMiniSerializer(read_only=True)
last_modified_by = UserMiniSerializer(read_only=True)
time_created = DateTimeField(format="%d-%m-%Y %H:%M")
time_modified = DateTimeField(format="%d-%m-%Y %H:%M")
def get_field_names(self, declared_fields, info):
expanded_fields = super(BaseSerializer, self).get_field_names(declared_fields, info)
if getattr(self.Meta, 'extra_fields', None):
return expanded_fields + self.Meta.extra_fields
else:
return expanded_fields
class PostDetailSerializer(ModelSerializer):
create_date = DateTimeField(format='%Y-%m-%d %H:%M:%S.%f')
update_date = DateTimeField(format='%Y-%m-%d %H:%M:%S.%f')
url = HyperlinkedIdentityField(view_name='post_detail', lookup_field='pk')
update_url = HyperlinkedIdentityField(view_name='post_update',
lookup_field='pk')
delete_url = HyperlinkedIdentityField(view_name='post_delete',
lookup_field='pk')
class Meta:
model = Post
fields = ('id', 'user', 'title', 'contents', 'create_date',
'update_date', 'url', 'update_url', 'delete_url')
class UserSerializer(DynamicModelSerializer):
password = CharField(required=True, write_only=True)
firstName = CharField(required=False, source='first_name')
lastName = CharField(required=False, source='last_name')
createdAt = DateTimeField(read_only=True, source='date_joined')
lastLogin = DateTimeField(read_only=True, source='last_login')
def create(self, validated_data):
return User.objects.create_user(**validated_data)
class Meta:
model = User
name = 'user'
fields = ('id', 'username', 'firstName', 'lastName', 'password',
'createdAt', 'lastLogin')
class TransactionSerializer(Serializer):
""" Serialize a single transaction """
id = IntegerField()
amount = MoneyField()
product_name = CharField()
product = ProductSerializer()
created_at = DateTimeField()
class FeedbackSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
timestamp = DateTimeField(read_only=True)
shopSlug = SlugField(write_only=True)
def validate_shopSlug(self, slug):
shop_qs = Shop.objects.filter(slug=slug)
if shop_qs.exists() and shop_qs.count() == 1:
return shop_qs.first()
raise ValidationError(
'Sorry cannot find the shop you are commentig on')
def create(self, validate_data):
shopSlug = validate_data['shopSlug']
shop = validate_data['shopSlug']
content = validate_data["content"]
user = self.context['request'].user
# print ("hello")
# print (self.context['request'].COOKIES['token'])
# print(self.context['request'].META['REMOTE_ADDR'])
return Feedback.objects.create(user=user, shop=shop, content=content)
class Meta:
model = Feedback
fields = ['shopSlug', 'user', 'content', 'timestamp']
class FeedbackListSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
timestamp = DateTimeField(read_only=True)
class Meta:
model = Feedback
fields = ['user', 'content', 'timestamp']
class BookingSerializer(serializers.ModelSerializer):
booking_time = DateTimeField()
advisor = serializers.PrimaryKeyRelatedField(queryset=Advisor.objects.all())
user = serializers.PrimaryKeyRelatedField(queryset=User.objects.all())
class Meta:
model = Booking
fields = ['id','booking_time', 'advisor', 'user']
def validate_booking_time(self,value): # check if booking time is greater than today & starts at a quarter of an hour
input = value
present = datetime.now()
minutes = int(input.strftime("%M"))
if input.date() < present.date():
raise serializers.ValidationError("Booking time should be greater than today!")
elif minutes % 15 != 0:
raise serializers.ValidationError("Booking time should be at every quarter of every hour!")
else:
return value
def check_booking_time_available(self,advisor_id,booking_time): # check if booking time is available
advisor = Advisor.objects.get(id=advisor_id)
# check if advisor id valid
if advisor is not None:
# find all booking with advisor at the same booking time
booking = advisor.booked_advisors.filter(booking_time=booking_time)
if not booking:
return True
else:
raise serializers.ValidationError("Booking time is already booked!") # time already booked
else:
raise serializers.ValidationError("Advisor is not registered!") # if advisor id not valid
class PostSerializer(ModelSerializer):
published_datetime = DateTimeField()
feed = SerializerMethodField()
is_bookmark = SerializerMethodField()
def get_feed(self, post):
qs = UserFeed.objects.filter(url=post.feed_url)
serializer = UserFeedPostSerializer(instance=qs, many=True)
return serializer.data
def get_is_bookmark(self, post):
request = self.context.get('request', None)
if not request:
return False
if not request.user.is_authenticated:
return False
return Favorite.objects.filter(user=request.user, post=post).exists()
class Meta:
model = Post
fields = (
'id',
'title',
'link',
'link_hash',
'published_datetime',
'feed',
'is_bookmark',
)