mayan-edms/mayan/apps/documents/serializers.py

from __future__ import unicode_literals

from django.utils.encoding import force_text

from rest_framework import serializers
from rest_framework.reverse import reverse

from mayan.apps.common.models import SharedUploadedFile
from mayan.apps.rest_api.relations import MultiKwargHyperlinkedIdentityField
from mayan.apps.rest_api.serializers import LazyExtraFieldsHyperlinkedModelSerializer

from .models import (
    Document, DocumentPage, DocumentType, DocumentTypeFilename,
    DocumentVersion, RecentDocument
)
from .settings import setting_language
from .tasks import task_upload_new_version


class DocumentPageSerializer(LazyExtraFieldsHyperlinkedModelSerializer):
    image_url = MultiKwargHyperlinkedIdentityField(
        view_kwargs=(
            {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_page_id',
            },
            {
                'lookup_field': 'document.pk', 'lookup_url_kwarg': 'document_id',
            },
            {
                'lookup_field': 'document_version_id', 'lookup_url_kwarg': 'document_version_id',
            },
        ),
        view_name='rest_api:document_page-image'
    )
    document_version_url = MultiKwargHyperlinkedIdentityField(
        view_kwargs=(
            {
                'lookup_field': 'document_version_id', 'lookup_url_kwarg': 'document_version_id',
            },
            {
                'lookup_field': 'document.pk', 'lookup_url_kwarg': 'document_id',
            }
        ),
        view_name='rest_api:document_version-detail'
    )
    url = MultiKwargHyperlinkedIdentityField(
        view_kwargs=(
            {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_page_id',
            },
            {
                'lookup_field': 'document.pk', 'lookup_url_kwarg': 'document_id',
            },
            {
                'lookup_field': 'document_version_id', 'lookup_url_kwarg': 'document_version_id',
            },
        ),
        view_name='rest_api:document_page-detail'
    )

    class Meta:
        fields = ('document_version_url', 'image_url', 'page_number', 'url')
        model = DocumentPage


class DocumentTypeFilenameSerializer(serializers.ModelSerializer):
    class Meta:
        model = DocumentTypeFilename
        fields = ('filename',)


class DocumentTypeSerializer(serializers.HyperlinkedModelSerializer):
    documents_url = serializers.HyperlinkedIdentityField(
        lookup_url_kwarg='document_type_id',
        view_name='rest_api:document_type-document-list'
    )
    #documents_count = serializers.SerializerMethodField()
    #filenames = DocumentTypeFilenameSerializer(many=True, read_only=True)

    class Meta:
        extra_kwargs = {
            'url': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_type_id',
                'view_name': 'rest_api:document_type-detail'
            }
        }
        fields = (
            'delete_time_period', 'delete_time_unit', 'documents_url',
            #'documents_count', 'filenames',
            'id', 'label', 'trash_time_period',
            'trash_time_unit', 'url'
        )
        model = DocumentType

    #def get_documents_count(self, obj):
    #    return obj.documents.count()

"""
class WritableDocumentTypeSerializer(serializers.ModelSerializer):
    documents_url = serializers.HyperlinkedIdentityField(
        lookup_field='pk', lookup_url_kwarg='document_type_id',
        view_name='rest_api:documenttype-document-list'
    )
    documents_count = serializers.SerializerMethodField()

    class Meta:
        extra_kwargs = {
            'url': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_type_id',
                'view_name': 'rest_api:documenttype-detail'
            }
        }
        fields = (
            'delete_time_period', 'delete_time_unit', 'documents_url',
            'documents_count', 'id', 'label', 'trash_time_period',
            'trash_time_unit', 'url'
        )
        model = DocumentType

    def get_documents_count(self, obj):
        return obj.documents.count()
"""

class DocumentVersionSerializer(LazyExtraFieldsHyperlinkedModelSerializer):
    #download_url = serializers.SerializerMethodField()
    document_url = serializers.HyperlinkedIdentityField(
        lookup_field='document_id', lookup_url_kwarg='document_id',
        view_name='rest_api:document-detail'
    )
    document_page_list_url = MultiKwargHyperlinkedIdentityField(
        view_kwargs=(
            {
                'lookup_field': 'document_id', 'lookup_url_kwarg': 'document_id',
            },
            {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_version_id',
            }
        ),
        view_name='rest_api:document_page-list'
    )

    size = serializers.SerializerMethodField()
    url = MultiKwargHyperlinkedIdentityField(
        view_kwargs=(
            {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_version_id',
            },
            {
                'lookup_field': 'document_id', 'lookup_url_kwarg': 'document_id',
            },
        ),
        view_name='rest_api:document_version-detail'
    )

    class Meta:
        extra_kwargs = {
            'file': {'use_url': False},
        }
        fields = (
            # 'download_url',
            'checksum', 'comment', 'document_url', 'encoding',
            'file', 'mimetype', 'document_page_list_url', 'size', 'timestamp', 'url'
        )
        model = DocumentVersion
        read_only_fields = ('document', 'file', 'size')

    def get_size(self, instance):
        return instance.size

    def build_url_field(self, field_name, model_class):
        """
        Create a field representing the object's own URL.
        """
        field_class = self.serializer_url_field
        field_kwargs = {'kwargs': 1}

        return field_class, field_kwargs

    """
    def get_document_url(self, instance):
        return reverse(
            viewname='rest_api:document-detail', kwargs={
                'document_id': instance.document.pk
            }, request=self.context['request']#, format=self.context['format']
        )

    def get_download_url(self, instance):
        return reverse(
            viewname='rest_api:document_version-download', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request']#, format=self.context['format']
        )

    def get_pages_url(self, instance):
        return reverse(
            viewname='rest_api:document_version-page-list', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request']#, format=self.context['format']
        )


    def get_url(self, obj, view_name, request, format):
        print ' obj, view_name, request, format', obj, view_name, request, format
        # Unsaved objects will not yet have a valid URL.
        if hasattr(obj, 'pk') and obj.pk in (None, ''):
            return None

        lookup_value = getattr(obj, self.lookup_field)
        kwargs = {self.lookup_url_kwarg: lookup_value}
        return self.reverse(view_name, kwargs=kwargs, request=request, format=format)
    """
    """

    def get_url(self, instance, *args, **kwargs):
        print ', *args, **kwargs', args, kwargs
        return reverse(
            viewname='rest_api:document_version-detail', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request']#, format=self.context['format']
        )
    """
"""
class WritableDocumentVersionSerializer(serializers.ModelSerializer):
    document_url = serializers.SerializerMethodField()
    download_url = serializers.SerializerMethodField()
    pages_url = serializers.SerializerMethodField()
    url = serializers.SerializerMethodField()

    class Meta:
        extra_kwargs = {
            'file': {'use_url': False},
        }
        fields = (
            'checksum', 'comment', 'document_url', 'download_url', 'encoding',
            'file', 'mimetype', 'pages_url', 'timestamp', 'url'
        )
        model = DocumentVersion
        read_only_fields = ('document', 'file')

    def get_document_url(self, instance):
        return reverse(
            viewname='rest_api:document-detail', kwargs={
                'document_id': instance.document.pk
            }, request=self.context['request'], format=self.context['format']
        )

    def get_download_url(self, instance):
        return reverse(
            viewname='rest_api:documentversion-download', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request'], format=self.context['format']
        )

    def get_pages_url(self, instance):
        return reverse(
            viewname='rest_api:documentversion-page-list', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request'], format=self.context['format']
        )

    def get_url(self, instance):
        return reverse(
            viewname='rest_api:documentversion-detail', kwargs={
                'document_id': instance.document.pk,
                'document_version_id': instance.pk
            }, request=self.context['request'], format=self.context['format']
        )


class NewDocumentVersionSerializer(serializers.Serializer):
    comment = serializers.CharField(allow_blank=True)
    file = serializers.FileField(use_url=False)

    def save(self, document, _user):
        shared_uploaded_file = SharedUploadedFile.objects.create(
            file=self.validated_data['file']
        )

        task_upload_new_version.delay(
            comment=self.validated_data.get('comment', ''),
            document_id=document.pk,
            shared_uploaded_file_id=shared_uploaded_file.pk, user_id=_user.pk
        )
"""

class DeletedDocumentSerializer(serializers.HyperlinkedModelSerializer):
    document_type_label = serializers.SerializerMethodField()
    restore = serializers.HyperlinkedIdentityField(
        lookup_field='pk', lookup_url_kwarg='document_id',
        view_name='rest_api:trasheddocument-restore'
    )

    class Meta:
        extra_kwargs = {
            'document_type': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_type_id',
                'view_name': 'rest_api:documenttype-detail'
            },
            'url': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_id',
                'view_name': 'rest_api:trasheddocument-detail'
            }
        }
        fields = (
            'date_added', 'deleted_date_time', 'description', 'document_type',
            'document_type_label', 'id', 'label', 'language', 'restore',
            'url', 'uuid',
        )
        model = Document
        read_only_fields = (
            'deleted_date_time', 'description', 'document_type', 'label',
            'language'
        )

    def get_document_type_label(self, instance):
        return instance.document_type.label


class DocumentSerializer(LazyExtraFieldsHyperlinkedModelSerializer):
    document_type = DocumentTypeSerializer(read_only=True)
    #document_type_url = serializers.HyperlinkedIdentityField(
    #    lookup_field='document_type_id', lookup_url_kwarg='document_type_id',
    #    view_name='rest_api:document_type-detail'
    #)
    latest_version = DocumentVersionSerializer(many=False, read_only=True)
    document_version_list_url = serializers.HyperlinkedIdentityField(
        lookup_field='pk', lookup_url_kwarg='document_id',
        view_name='rest_api:document_version-list'
    )

    class Meta:
        extra_kwargs = {
            'document_type': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_type_id',
                'view_name': 'rest_api:document_type-detail'
            },
            'url': {
                'lookup_field': 'pk', 'lookup_url_kwarg': 'document_id',
                'view_name': 'rest_api:document-detail'
            }
        }
        fields = (
            'date_added', 'description', 'document_type', 'id', 'label',
            #'document_type_url',
            'language', 'latest_version', 'url', 'uuid', 'document_version_list_url',
        )
        model = Document
        #read_only_fields = ('document_type', 'label')


"""
class WritableDocumentSerializer(serializers.ModelSerializer):
    document_type = DocumentTypeSerializer(read_only=True)
    latest_version = DocumentVersionSerializer(many=False, read_only=True)
    versions = serializers.HyperlinkedIdentityField(
        lookup_field='pk', lookup_url_kwarg='document_id',
        view_name='rest_api:document-version-list'
    )
    url = serializers.HyperlinkedIdentityField(
        lookup_field='pk', lookup_url_kwarg='document_id',
        view_name='rest_api:document-detail',
    )

    class Meta:
        fields = (
            'date_added', 'description', 'document_type', 'id', 'label',
            'language', 'latest_version', 'url', 'uuid', 'versions',
        )
        model = Document
        read_only_fields = ('document_type',)


class NewDocumentSerializer(serializers.ModelSerializer):
    file = serializers.FileField(write_only=True)

    def save(self, _user):
        document = Document.objects.create(
            description=self.validated_data.get('description', ''),
            document_type=self.validated_data['document_type'],
            label=self.validated_data.get(
                'label', force_text(self.validated_data['file'])
            ),
            language=self.validated_data.get(
                'language', setting_language.value
            )
        )
        document.save(_user=_user)

        shared_uploaded_file = SharedUploadedFile.objects.create(
            file=self.validated_data['file']
        )

        task_upload_new_version.delay(
            document_id=document.pk,
            shared_uploaded_file_id=shared_uploaded_file.pk, user_id=_user.pk
        )

        self.instance = document
        return document

    class Meta:
        fields = (
            'description', 'document_type', 'id', 'file', 'label', 'language',
        )
        model = Document
"""

class RecentDocumentSerializer(serializers.ModelSerializer):
    class Meta:
        fields = ('document', 'datetime_accessed')
        model = RecentDocument