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