class AlgorithmSerializer(serializers.ModelSerializer):
average_duration = SerializerMethodField()
inputs = ComponentInterfaceSerializer(many=True)
outputs = ComponentInterfaceSerializer(many=True)
logo = URLField(source="logo.x20.url", read_only=True)
url = URLField(source="get_absolute_url", read_only=True)
class Meta:
model = Algorithm
fields = [
"api_url",
"url",
"description",
"pk",
"title",
"logo",
"slug",
"average_duration",
"inputs",
"outputs",
]
def get_average_duration(self, obj: Algorithm) -> Optional[float]:
"""The average duration of successful jobs in seconds"""
if obj.average_duration is None:
return None
else:
return obj.average_duration.total_seconds()
class ReaderStudySerializer(HyperlinkedModelSerializer):
questions = QuestionSerializer(many=True, read_only=True)
hanging_list_images = SerializerMethodField()
help_text = ReadOnlyField()
case_text = ReadOnlyField(source="cleaned_case_text")
logo = URLField(source="logo.x20.url", read_only=True)
url = URLField(source="get_absolute_url", read_only=True)
class Meta:
model = ReaderStudy
fields = (
"api_url",
"url",
"slug",
"logo",
"description",
"help_text",
"hanging_list_images",
"is_valid",
"pk",
"questions",
"title",
"is_educational",
"has_ground_truth",
"case_text",
"allow_answer_modification",
"allow_case_navigation",
"allow_show_all_annotations",
)
def get_hanging_list_images(self, obj: ReaderStudy):
"""Used by hanging_list_images serializer field."""
return obj.get_hanging_list_images_for_user(
user=self.context["request"].user)
class HomeSectionItemSerializer(ModelSerializer):
id = CharField(source='naturitas_id', required=False, allow_blank=True)
image = URLField(source='image_url')
link = URLField(source='link_url')
class Meta:
model = HomeSectionItem
fields = ('id', 'type', 'name', 'image', 'link', 'deeplink')
def to_representation(self, instance):
result = super().to_representation(instance)
return OrderedDict([(key, result[key]) for key in result
if result[key] is not None])
class ContainerAppSerializer(serializers.ModelSerializer):
absolute_url = URLField(source='get_absolute_url', read_only=True)
container = serializers.HyperlinkedRelatedField(
view_name='container-detail',
lookup_field='pk',
queryset=Container.objects.all())
container_name = serializers.SlugRelatedField(source='container',
slug_field='display_name',
read_only=True)
removal_plan = serializers.HyperlinkedIdentityField(
view_name='containerapp-removal-plan')
argument_list = serializers.HyperlinkedIdentityField(
view_name='containerapp-argument-list')
class Meta:
model = ContainerApp
fields = ('id', 'url', 'absolute_url', 'container', 'container_name',
'name', 'description', 'threads', 'memory', 'inputs',
'outputs', 'argument_list', 'removal_plan')
def save(self, **kwargs):
app = super(ContainerAppSerializer, self).save(**kwargs)
app.write_inputs(self.initial_data.get('inputs', ''))
app.write_outputs(self.initial_data.get('outputs', ''))
return app
class NewsLinkSerializer(Serializer):
id = IntegerField(read_only=True)
title = CharField(max_length=63)
slug = SlugField(max_length=63)
pub_date = DateField()
link = URLField(max_length=255)
startup = StartupSerializer()
class BookmarkManualSerializer(Serializer):
"""
"""
id = IntegerField(read_only=True)
link = URLField(required=False, max_length=1000)
def create(self, validated_data):
"""
Create and return a new 'Bookmark' instance, given the validated data.
:param validated_data:
:return:
"""
return Bookmark.objects.create(**validated_data)
def update(self, instance, validated_data):
"""
Update and return an existing 'Snippet' instance, given the validated data.
:param instance:
:param validated_data:
:return:
"""
instance.url = validated_data.get('url', instance.url)
instance.save()
return instance
class StackFrameSerializer(Serializer):
# https://github.com/stacktracejs/stackframe
fileName = URLField(required=False)
functionName = CharField(max_length=255, required=False)
args = CharField(max_length=255, required=False)
lineNumber = IntegerField(min_value=0,required=False)
columnNumber = IntegerField(min_value=0,required=False)
class ChatMessageSerializer(serializers.ModelSerializer):
author_profile_view = URLField(source='author.profile.get_absolute_url')
author_name = CharField(source='author.username')
class Meta:
model = ChatMessage
fields = ('id', 'text', 'author', 'is_read', 'chat', 'author_name',
'author_profile_view')
read_only_fields = ('id', )
class StartupSerializer(Serializer):
id = IntegerField(read_only=True)
name = CharField(max_length=31)
slug = SlugField(max_length=31)
description = CharField()
founded_date = DateField()
contact = EmailField()
website = URLField(max_length=255)
tags = TagSerializer(many=True)
class ContainerSerializer(AccessControlSerializer,
serializers.ModelSerializer):
absolute_url = URLField(source='get_absolute_url', read_only=True)
family = serializers.HyperlinkedRelatedField(
view_name='containerfamily-detail',
lookup_field='pk',
queryset=ContainerFamily.objects.all())
family_name = serializers.SlugRelatedField(
source='family',
slug_field='name',
read_only=True)
parent = serializers.HyperlinkedRelatedField(
view_name='container-detail',
lookup_field='pk',
queryset=Container.objects.filter(file_type=Container.SIMG),
required=False,
allow_null=True)
download_url = serializers.HyperlinkedIdentityField(
view_name='container-download')
num_apps = serializers.IntegerField(read_only=True)
app_list = serializers.HyperlinkedIdentityField(
view_name='container-app-list')
content = serializers.HyperlinkedIdentityField(
view_name='container-content')
removal_plan = serializers.HyperlinkedIdentityField(
view_name='container-removal-plan')
class Meta:
model = Container
fields = ('id',
'url',
'download_url',
'absolute_url',
'family',
'family_name',
'parent',
'file',
'file_type',
'tag',
'description',
'md5',
'num_apps',
'created',
'user',
'users_allowed',
'groups_allowed',
'app_list',
'content',
'removal_plan')
def create(self, validated_data):
container = super(ContainerSerializer, self).create(validated_data)
if container.file_type != Container.SIMG:
container.create_app_from_content()
return container
class ArchiveSerializer(serializers.ModelSerializer):
algorithms = HyperlinkedRelatedField(read_only=True,
many=True,
view_name="api:algorithm-detail")
logo = URLField(source="logo.x20.url", read_only=True)
url = URLField(source="get_absolute_url", read_only=True)
# Include the read only name for legacy clients
name = ReadOnlyField()
class Meta:
model = Archive
fields = (
"id",
"name",
"title",
"algorithms",
"logo",
"description",
"api_url",
"url",
)
class CubariSerializer(ModelSerializer):
"""Serializer for cubari.moe."""
title = CharField(read_only=True)
description = CharField(read_only=True)
original_url = URLField(source='get_absolute_url', read_only=True)
artist = SerializerMethodField(method_name='_get_artist')
author = SerializerMethodField(method_name='_get_author')
cover = SerializerMethodField(method_name='_get_cover')
alt_titles = SerializerMethodField(method_name='_get_aliases')
metadata = SerializerMethodField(method_name='_get_metadata')
chapters = SerializerMethodField(method_name='_get_chapters')
def __uri(self, path: str) -> str:
return self.context['view'].request.build_absolute_uri(path)
def _get_artist(self, obj: Series) -> str:
return ', '.join(a.name for a in obj.artists.all())
def _get_author(self, obj: Series) -> str:
return ', '.join(a.name for a in obj.authors.all())
def _get_cover(self, obj: Series) -> str:
return self.__uri(obj.cover.url)
def _get_aliases(self, obj: Series) -> List[str]:
return obj.aliases.names()
def _get_metadata(self, obj: Series) -> List[List[str]]:
return [
['Author', self._get_author(obj)],
['Artist', self._get_artist(obj)],
# TODO: Views & Last Updated
]
def _get_chapters(self, obj: Series) -> Dict[str, Dict]:
return {
f'{ch.number:g}': {
'title': ch.title,
'volume': str(ch.volume),
'groups': {
', '.join(g.name for g in ch.groups.all()) or 'N/A':
[self.__uri(p.image.url) for p in ch.pages.all()]
},
'last_updated': str(round(ch.modified.timestamp()))
}
for ch in obj.chapters.all()
}
class Meta:
model = Series
fields = ('title', 'cover', 'original_url', 'description', 'author',
'artist', 'alt_titles', 'metadata', 'chapters')
class _SeriesDetailSerializer(ModelSerializer):
"""
Serializer for series details.
.. admonition:: TODO
:class: warning
Make M2M fields editable.
"""
updated = DateTimeField(source='latest_upload',
read_only=True,
help_text='The latest chapter upload date.')
views = IntegerField(min_value=0,
read_only=True,
help_text='The total chapter views of the series.')
aliases = StringRelatedField(
many=True,
required=False,
help_text='The alternative titles of the series.')
authors = StringRelatedField(many=True,
required=False,
help_text='The authors of the series.')
artists = StringRelatedField(many=True,
required=False,
help_text='The artists of the series.')
categories = StringRelatedField(many=True,
required=False,
help_text='The categories of the series.')
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of the series.')
def create(self, validated_data: Dict) -> Series:
"""Create a new ``Series`` instance."""
# manually set the manager to the current user
return super().create({
**validated_data, 'manager_id':
self.context['request'].user.id
})
class Meta:
model = Series
fields = ('slug', 'title', 'url', 'cover', 'updated', 'description',
'views', 'completed', 'licensed', 'format', 'aliases',
'authors', 'artists', 'categories')
extra_kwargs = {
'format': {
'write_only': True,
'default': 'Vol. {volume}, Ch. {number}: {title}'
}
}
class ContainerFamilySerializer(AccessControlSerializer,
serializers.ModelSerializer):
absolute_url = URLField(source='get_absolute_url', read_only=True)
num_containers = serializers.IntegerField()
removal_plan = serializers.HyperlinkedIdentityField(
view_name='containerfamily-removal-plan')
containers = serializers.HyperlinkedIdentityField(
view_name="containerfamily-containers")
class Meta:
model = ContainerFamily
fields = ("id", "url", "absolute_url", "name", "description", "git",
"user", "users_allowed", "groups_allowed", "num_containers",
"containers", "removal_plan")
class UserSerializer(serializers.ModelSerializer):
avatar = ImageField(source='profile.avatar')
profile_view = URLField(source='profile.get_absolute_url')
class Meta:
model = User
fields = (
'id',
'username',
'first_name',
'last_name',
'avatar',
'profile_view',
)
read_only_fields = ('id', )
class UserProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
location = CountryField(source="country")
mugshot = URLField(source="mugshot.x20.url", read_only=True, default="")
class Meta:
model = UserProfile
fields = (
"user",
"mugshot",
"institution",
"department",
"location",
"website",
)
class ConceptVersionDetailSerializer(ModelSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='mnemonic')
names = LocalizedNameSerializer(many=True)
descriptions = LocalizedDescriptionSerializer(many=True, required=False, allow_null=True)
source = CharField(source='parent_resource')
source_url = URLField(source='parent_url')
owner = CharField(source='owner_name')
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
version_created_on = DateTimeField(source='created_at')
version_created_by = CharField(source='created_by')
locale = CharField(source='iso_639_1_locale')
mappings = SerializerMethodField()
url = CharField(source='versioned_object_url', read_only=True)
previous_version_url = CharField(source='prev_version_uri', read_only=True)
update_comment = CharField(source='comment', required=False, allow_null=True, allow_blank=True)
def __init__(self, *args, **kwargs):
params = get(kwargs, 'context.request.query_params')
self.include_indirect_mappings = False
self.include_direct_mappings = False
self.query_params = params.dict() if params else dict()
self.include_indirect_mappings = self.query_params.get(INCLUDE_INVERSE_MAPPINGS_PARAM) == 'true'
self.include_direct_mappings = self.query_params.get(INCLUDE_MAPPINGS_PARAM) == 'true'
super().__init__(*args, **kwargs)
class Meta:
model = Concept
fields = (
'type', 'uuid', 'id', 'external_id', 'concept_class', 'datatype', 'display_name', 'display_locale',
'names', 'descriptions', 'extras', 'retired', 'source', 'source_url', 'owner', 'owner_name', 'owner_url',
'version', 'created_on', 'updated_on', 'version_created_on', 'version_created_by', 'update_comment',
'is_latest_version', 'locale', 'url', 'owner_type', 'version_url', 'mappings', 'previous_version_url'
)
def get_mappings(self, obj):
from core.mappings.serializers import MappingDetailSerializer
context = get(self, 'context')
if self.include_direct_mappings:
return MappingDetailSerializer(obj.get_unidirectional_mappings(), many=True, context=context).data
if self.include_indirect_mappings:
return MappingDetailSerializer(obj.get_bidirectional_mappings(), many=True, context=context).data
return []
class ConceptVersionDetailSerializer(ModelSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='mnemonic')
names = LocalizedNameSerializer(many=True)
descriptions = LocalizedDescriptionSerializer(many=True)
source = CharField(source='parent_resource')
source_url = URLField(source='owner_url')
owner = CharField(source='owner_name')
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
version_created_on = DateTimeField(source='created_at')
version_created_by = CharField(source='created_by')
locale = CharField(source='iso_639_1_locale')
class Meta:
model = Concept
fields = (
'type',
'uuid',
'id',
'external_id',
'concept_class',
'datatype',
'display_name',
'display_locale',
'names',
'descriptions',
'extras',
'retired',
'source',
'source_url',
'owner',
'owner_name',
'owner_url',
'version',
'created_on',
'updated_on',
'version_created_on',
'version_created_by',
'extras',
'is_latest_version',
'locale',
'url',
'owner_type',
'version_url',
)
class _SeriesListSerializer(ModelSerializer):
"""Serializer for series lists."""
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of the series.')
updated = DateTimeField(source='latest_upload',
read_only=True,
help_text='The latest chapter upload date.')
chapters = SerializerMethodField(
method_name='_get_chapters',
allow_null=True,
help_text='The number of chapters or null if licensed.')
def _get_chapters(self, obj: Series) -> Optional[int]:
return None if obj.licensed else getattr(obj, 'chapter_count')
class Meta:
model = Series
fields = ('slug', 'title', 'url', 'cover', 'updated', 'chapters')
class ChapterSerializer(ModelSerializer):
"""Serializer for chapters."""
full_title = CharField(source='__str__',
read_only=True,
help_text='The formatted title of the chapter.')
views = IntegerField(min_value=0,
read_only=True,
help_text='The total views of the chapter.')
series = SlugRelatedField(queryset=Series.objects.only('slug', 'title'),
slug_field='slug',
help_text='The series of the chapter.')
groups = StringRelatedField(
many=True, help_text='The scanlation groups of the chapter.')
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of the chapter.')
def to_representation(self, instance: Chapter) -> Dict:
rep = super().to_representation(instance)
# HACK: adapt the date format based on a query param
dt_format = self.context['request'] \
.query_params.get('date_format', 'iso-8601')
published = instance.published
rep['published'] = {
'iso-8601': published.strftime('%Y-%m-%dT%H:%M:%SZ'),
'rfc-5322': published.strftime('%a, %d %b %Y %H:%M:%S GMT'),
'timestamp': str(round(published.timestamp() * 1e3))
}.get(dt_format)
return rep
def __uri(self, path: str) -> str:
return self.context['view'].request.build_absolute_uri(path)
def _get_pages(self, obj: Chapter) -> List[str]:
return [self.__uri(p.image.url) for p in obj.pages.iterator()]
class Meta:
model = Chapter
fields = ('id', 'title', 'number', 'volume', 'published', 'views',
'final', 'series', 'groups', 'full_title', 'url', 'file')
extra_kwargs = {'file': {'write_only': True}}
class PageSerializer(ModelSerializer):
"""Serializer for chapter pages."""
chapter = PrimaryKeyRelatedField(help_text="The ID of the page's chapter.",
queryset=Chapter.objects.all(),
write_only=True)
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of the page.')
class Meta:
model = Page
fields = ('id', 'chapter', 'image', 'number', 'url')
extra_kwargs = {
'image': {
'help_text': 'The image of the page.'
},
'number': {
'help_text': 'The number of the page.'
}
}
validators = (UniqueTogetherValidator(
queryset=Page.objects.all(),
fields=('chapter', 'number'),
message='The chapter already has a page with this number.'), )
class ProfileSerializer(ModelSerializer):
"""Serializer for user profiles."""
username = CharField(
source='user.username',
max_length=150,
required=True,
help_text='Your (unique) username.',
validators=(UnicodeUsernameValidator(), ),
)
first_name = CharField(source='user.first_name',
max_length=150,
required=False,
help_text='Your first name.')
last_name = CharField(source='user.last_name',
max_length=150,
required=False,
help_text='Your last name.')
email = EmailField(source='user.email',
max_length=254,
required=True,
help_text='Your e-mail address.')
password = CharField(
source='user.password',
min_length=8,
max_length=128,
required=False,
write_only=True,
style={'input_type': 'password'},
help_text='You can set this if you want to change your password.')
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of your profile.')
def validate_username(self, value: str) -> str:
if not value:
return ''
users = User.objects.filter(username=value)
if users.exclude(id=self.context['request'].user.id).exists():
from rest_framework.exceptions import ValidationError
raise ValidationError('This username is already taken.')
return value
class Meta:
model = UserProfile
fields = (
'username',
'first_name',
'last_name',
'email',
'bio',
'avatar',
'password',
'url',
)
extra_kwargs = {
'bio': {
'help_text': 'Some info about yourself.',
'label': None
},
'avatar': {
'help_text': 'Your avatar image. (<2MBs)',
'allow_null': True
},
'username': {
'pattern': '^[-a-zA-Z0-9@+_.]+$'
}
}
SlugField(),
{
'type': 'string',
'pattern': '^[-a-zA-Z0-9_]+$'
},
),
(
# TimeField
TimeField(),
{
'type': 'string'
},
),
(
# URLField
URLField(),
{
'type': 'string',
'format': 'uri',
'pattern': url_pattern
},
),
(
# UUIDField
UUIDField(),
{
'type': 'string',
'format': 'uuid'
},
),
(
class VideoSerializer(serializers.HyperlinkedModelSerializer):
listas = ListaSerializer(many=True)
links = LinkSerializer(many=True)
tags = TagsField(read_only=True)
thumbnail_120 = HyperlinkedSorlImageField('120',
source='imagen',
read_only=True)
thumbnail_360 = HyperlinkedSorlImageField('360',
source='imagen',
read_only=True)
thumbnail_640 = HyperlinkedSorlImageField('640',
source='imagen',
read_only=True)
thumbnail_1280 = HyperlinkedSorlImageField('1280',
source='imagen',
read_only=True)
thumbnail_120x67 = HyperlinkedSorlImageField('120x67',
source='imagen',
read_only=True)
thumbnail_360_202 = HyperlinkedSorlImageField('360x202',
source='imagen',
read_only=True)
thumbnail_640x360 = HyperlinkedSorlImageField('640x360',
source='imagen',
read_only=True)
thumbnail_1280x720 = HyperlinkedSorlImageField('1280x720',
source='imagen',
read_only=True)
url = URLField(source='get_absolute_url')
class Meta:
model = Video
fields = FIELDS_BASE + (
# status
'estado',
'procesamiento',
'fecha',
'status_path',
'procesamiento_status',
# editorial
'titulo',
'descripcion',
'descripcion_plain',
'ciudad',
'fecha_publicacion',
# source
'origen',
'origen_url',
'youtube_id',
# stream
'duracion',
'duracion_iso',
'horas',
'minutos',
'segundos',
'resolucion',
'width',
'height',
# frontend
'url',
'player',
# relations
'listas',
'links',
'paginas',
# files
'archivo',
'hls',
'dash',
'sprites',
'captions',
# meta
'tags',
'meta_descripcion',
'observaciones',
'custom_metadata',
'viejo_slug',
# thumbnails
'thumbnail_120',
'thumbnail_360',
'thumbnail_360',
'thumbnail_640',
'thumbnail_1280',
'thumbnail_120x67',
'thumbnail_360_202',
'thumbnail_640x360',
'thumbnail_1280x720',
)
class ConceptDetailSerializer(ModelSerializer):
version = CharField(read_only=True)
type = CharField(source='versioned_resource_type', read_only=True)
id = CharField(source='mnemonic', required=True)
source = CharField(source='parent_resource', read_only=True)
parent_id = UUIDField()
owner = CharField(source='owner_name', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
names = LocalizedNameSerializer(many=True)
descriptions = LocalizedDescriptionSerializer(many=True)
external_id = CharField(required=False, allow_blank=True)
concept_class = CharField(required=True)
datatype = CharField(required=True)
display_name = CharField(read_only=True)
display_locale = CharField(read_only=True)
retired = BooleanField(required=False)
url = URLField(read_only=True)
owner_type = CharField(read_only=True)
owner_url = URLField(read_only=True)
extras = JSONField(required=False)
update_comment = CharField(required=False, source='comment')
class Meta:
model = Concept
fields = (
'id',
'external_id',
'concept_class',
'datatype',
'url',
'retired',
'source',
'owner',
'owner_type',
'owner_url',
'display_name',
'display_locale',
'names',
'descriptions',
'created_on',
'updated_on',
'versions_url',
'version',
'extras',
'parent_id',
'name',
'type',
'update_comment',
'version_url',
)
def create(self, validated_data):
concept = Concept.persist_new(data=validated_data,
user=self.context.get('request').user)
self._errors.update(concept.errors)
return concept
def update(self, instance, validated_data):
instance.concept_class = validated_data.get('concept_class',
instance.concept_class)
instance.datatype = validated_data.get('datatype', instance.datatype)
instance.extras = validated_data.get('extras', instance.extras)
instance.external_id = validated_data.get('external_id',
instance.external_id)
instance.comment = validated_data.get(
'update_comment') or validated_data.get('comment')
instance.retired = validated_data.get('retired', instance.retired)
new_names = [
LocalizedText(
**{k: v
for k, v in name.items() if k not in ['name_type']})
for name in validated_data.get('names', [])
]
new_descriptions = [
LocalizedText(**{
k: v
for k, v in desc.items() if k not in ['description_type']
}) for desc in validated_data.get('descriptions', [])
]
instance.cloned_names = compact(new_names)
instance.cloned_descriptions = compact(new_descriptions)
errors = Concept.persist_clone(instance,
self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
class ContainerRunSerializer(AccessControlSerializer,
serializers.ModelSerializer):
datasets = ContainerDatasetSerializer(many=True,
required=False,
write_only=True)
dataset_list = serializers.HyperlinkedIdentityField(
view_name='containerrun-dataset-list')
log_list = serializers.HyperlinkedIdentityField(
view_name='containerrun-log-list')
absolute_url = URLField(source='get_absolute_url', read_only=True)
app = serializers.HyperlinkedRelatedField(
view_name='containerapp-detail',
lookup_field='pk',
queryset=ContainerApp.objects.all(),
required=False)
app_name = serializers.SlugRelatedField(source='app',
slug_field='display_name',
read_only=True)
batch = serializers.HyperlinkedRelatedField(view_name='batch-detail',
lookup_field='pk',
queryset=Batch.objects.all(),
required=False)
batch_name = serializers.SlugRelatedField(source='batch',
slug_field='name',
read_only=True)
batch_absolute_url = serializers.SlugRelatedField(
source='batch', slug_field='absolute_url', read_only=True)
original_run = serializers.HyperlinkedRelatedField(
view_name='containerrun-detail',
lookup_field='pk',
queryset=ContainerRun.objects.all(),
required=False)
stopped_by = serializers.SlugRelatedField(slug_field='username',
read_only=True)
removal_plan = serializers.HyperlinkedIdentityField(
view_name='containerrun-removal-plan')
class Meta:
model = ContainerRun
fields = ('id', 'url', 'absolute_url', 'name', 'description', 'batch',
'batch_name', 'batch_absolute_url', 'original_run',
'has_changed', 'app', 'app_name', 'state', 'priority',
'slurm_job_id', 'return_code', 'stopped_by', 'is_redacted',
'start_time', 'end_time', 'user', 'users_allowed',
'groups_allowed', 'removal_plan', 'dataset_list', 'log_list',
'datasets')
read_only_fields = ('state', 'slurm_job_id', 'return_code',
'start_time', 'end_time')
def create(self, validated_data):
"""Create a Run and the inputs it contains."""
datasets = validated_data.pop("datasets", [])
original_run = validated_data.get('original_run')
if original_run is not None:
run, dependencies = self.create_rerun(original_run,
validated_data['user'])
transaction.on_commit(lambda: run.schedule(dependencies))
else:
run = super(ContainerRunSerializer, self).create(validated_data)
run.validate_restrict_access(run.get_access_limits())
dataset_serializer = ContainerDatasetSerializer()
for dataset in datasets:
dataset['run'] = run
dataset_serializer.create(dataset)
return run
def create_rerun(self, original_run, user):
rerun = ContainerRun.objects.create(
user=user,
app=original_run.app,
batch=original_run.batch,
name=original_run.get_rerun_name(),
description=original_run.description,
priority=original_run.priority,
original_run=original_run)
rerun.copy_permissions(original_run)
reruns_needed = rerun.create_inputs_from_original_run()
dependencies = {} # {source_rerun_id: source_dependencies}
for source_run in reruns_needed:
source_rerun, source_dependencies = self.create_rerun(
source_run, user)
dependencies[source_rerun.id] = source_dependencies
return rerun, dependencies
class FakePrevNextListSerializer(BaseFakeListSerializer):
next = URLField()
previous = URLField()
class ConceptDetailSerializer(ModelSerializer):
uuid = CharField(source='id', read_only=True)
version = CharField(read_only=True)
type = CharField(source='versioned_resource_type', read_only=True)
id = CharField(source='mnemonic', required=True)
source = CharField(source='parent_resource', read_only=True)
parent_id = UUIDField()
owner = CharField(source='owner_name', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
names = LocalizedNameSerializer(many=True)
descriptions = LocalizedDescriptionSerializer(many=True, allow_null=True, required=False)
external_id = CharField(required=False, allow_blank=True)
concept_class = CharField(required=True)
datatype = CharField(required=True)
display_name = CharField(read_only=True)
display_locale = CharField(read_only=True)
retired = BooleanField(required=False)
owner_type = CharField(read_only=True)
owner_url = URLField(read_only=True)
extras = JSONField(required=False, allow_null=True)
update_comment = CharField(required=False, source='comment', allow_null=True, allow_blank=True)
mappings = SerializerMethodField()
url = CharField(required=False, source='versioned_object_url')
updated_by = DateTimeField(source='updated_by.username', read_only=True)
created_by = DateTimeField(source='created_by.username', read_only=True)
def __init__(self, *args, **kwargs):
params = get(kwargs, 'context.request.query_params')
self.query_params = params.dict() if params else dict()
self.include_indirect_mappings = self.query_params.get(INCLUDE_INVERSE_MAPPINGS_PARAM) in ['true', True]
self.include_direct_mappings = self.query_params.get(INCLUDE_MAPPINGS_PARAM) in ['true', True]
super().__init__(*args, **kwargs)
class Meta:
model = Concept
fields = (
'uuid', 'id', 'external_id', 'concept_class', 'datatype', 'url', 'retired', 'source',
'owner', 'owner_type', 'owner_url', 'display_name', 'display_locale', 'names', 'descriptions',
'created_on', 'updated_on', 'versions_url', 'version', 'extras', 'parent_id', 'name', 'type',
'update_comment', 'version_url', 'mappings', 'updated_by', 'created_by'
)
def get_mappings(self, obj):
from core.mappings.serializers import MappingDetailSerializer
context = get(self, 'context')
if self.include_indirect_mappings:
return MappingDetailSerializer(obj.get_bidirectional_mappings(), many=True, context=context).data
if self.include_direct_mappings:
return MappingDetailSerializer(obj.get_unidirectional_mappings(), many=True, context=context).data
return []
def create(self, validated_data):
concept = Concept.persist_new(data=validated_data, user=self.context.get('request').user)
if concept.errors:
self._errors.update(concept.errors)
return concept
def update(self, instance, validated_data):
errors = Concept.create_new_version_for(instance, validated_data, self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
class ConceptDetailSerializer(ModelSerializer):
uuid = CharField(source='id', read_only=True)
version = CharField(read_only=True)
type = CharField(source='versioned_resource_type', read_only=True)
id = CharField(source='mnemonic', required=True)
source = CharField(source='parent_resource', read_only=True)
parent_id = UUIDField()
owner = CharField(source='owner_name', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
names = LocalizedNameSerializer(many=True)
descriptions = LocalizedDescriptionSerializer(many=True, allow_null=True)
external_id = CharField(required=False, allow_blank=True)
concept_class = CharField(required=True)
datatype = CharField(required=True)
display_name = CharField(read_only=True)
display_locale = CharField(read_only=True)
retired = BooleanField(required=False)
owner_type = CharField(read_only=True)
owner_url = URLField(read_only=True)
extras = JSONField(required=False, allow_null=True)
update_comment = CharField(required=False, source='comment')
mappings = SerializerMethodField()
url = CharField(required=False, source='versioned_object_url')
updated_by = DateTimeField(source='updated_by.username', read_only=True)
created_by = DateTimeField(source='created_by.username', read_only=True)
def __init__(self, *args, **kwargs):
self.query_params = kwargs.get('context').get('request').query_params.dict()
self.include_indirect_mappings = self.query_params.get(INCLUDE_INVERSE_MAPPINGS_PARAM) == 'true'
self.include_direct_mappings = self.query_params.get(INCLUDE_MAPPINGS_PARAM) == 'true'
super().__init__(*args, **kwargs)
class Meta:
model = Concept
fields = (
'uuid', 'id', 'external_id', 'concept_class', 'datatype', 'url', 'retired', 'source',
'owner', 'owner_type', 'owner_url', 'display_name', 'display_locale', 'names', 'descriptions',
'created_on', 'updated_on', 'versions_url', 'version', 'extras', 'parent_id', 'name', 'type',
'update_comment', 'version_url', 'mappings', 'updated_by', 'created_by'
)
def get_mappings(self, obj):
if self.include_indirect_mappings:
return MappingDetailSerializer(obj.get_bidirectional_mappings(), many=True).data
if self.include_direct_mappings:
return MappingDetailSerializer(obj.get_unidirectional_mappings(), many=True).data
return []
def create(self, validated_data):
concept = Concept.persist_new(data=validated_data, user=self.context.get('request').user)
self._errors.update(concept.errors)
return concept
def update(self, instance, validated_data):
instance.concept_class = validated_data.get('concept_class', instance.concept_class)
instance.datatype = validated_data.get('datatype', instance.datatype)
instance.extras = validated_data.get('extras', instance.extras)
instance.external_id = validated_data.get('external_id', instance.external_id)
instance.comment = validated_data.get('update_comment') or validated_data.get('comment')
instance.retired = validated_data.get('retired', instance.retired)
new_names = [
LocalizedText(
**{k: v for k, v in name.items() if k not in ['name_type']}
) for name in validated_data.get('names', [])
]
new_descriptions = [
LocalizedText(
**{k: v for k, v in desc.items() if k not in ['description_type']}
) for desc in validated_data.get('descriptions', [])
]
instance.cloned_names = compact(new_names)
instance.cloned_descriptions = compact(new_descriptions)
errors = Concept.persist_clone(instance, self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
class RequestExternalSerializer(serializers.ModelSerializer):
videos = VideoDefaultSerializer(many=True, read_only=True)
comments = CommentDefaultSerializer(many=True, read_only=True)
requester = UserSerializer(read_only=True)
requested_by = UserSerializer(read_only=True)
responsible = UserSerializer(read_only=True)
comment_text = CharField(write_only=True, required=False, allow_blank=True)
requester_first_name = CharField(write_only=True)
requester_last_name = CharField(write_only=True)
requester_email = EmailField(write_only=True)
requester_mobile = PhoneNumberField(write_only=True)
callback_url = URLField(write_only=True)
class Meta:
model = Request
fields = (
"id",
"title",
"created",
"start_datetime",
"end_datetime",
"type",
"place",
"status",
"responsible",
"requester",
"requested_by",
"videos",
"comments",
"comment_text",
"requester_first_name",
"requester_last_name",
"requester_email",
"requester_mobile",
"callback_url",
)
read_only_fields = (
"id",
"created",
"status",
"responsible",
"requester",
"requested_by",
"videos",
"comments",
)
write_only_fields = (
"comment_text",
"requester_first_name",
"requester_last_name",
"requester_email",
"requester_mobile",
"callback_url",
)
def create(self, validated_data):
comment_text = validated_data.pop("comment_text", None)
callback_url = validated_data.pop("callback_url")
validated_data["requester"], additional_data = create_user(
validated_data)
validated_data["requested_by"] = self.context["request"].user
request = super(RequestExternalSerializer, self).create(validated_data)
if additional_data:
request.additional_data = additional_data
if comment_text:
request.comments.add(create_comment(comment_text, request))
request.additional_data["external"] = {}
request.additional_data["external"][
"sch_events_callback_url"] = callback_url
request.save()
create_calendar_event.delay(request.id)
email_user_new_request_confirmation.delay(request.id)
return request