Refactor preview: move from endpoint to contentapi

tracim/config.py

         #     self.RADICALE_CLIENT_BASE_URL_HOST,
         #     self.RADICALE_CLIENT_BASE_URL_PREFIX,
         # )
+        preview_jpg_allowed_sizes = settings.get('preview.jpg.allowed_sizes', '')  # nopep8
+        self.PREVIEW_JPG_ALLOWED_SIZES = []
+        if preview_jpg_allowed_sizes:
+            for size in preview_jpg_allowed_sizes.split(','):
+                parts = preview_jpg_allowed_sizes.split('x')
+                assert len(parts) == 2
+                width, height = parts
+                assert width.is_decimal()
+                assert height.is_decimal()
+                size = PreviewSize(int(width), int(height))
+                self.PREVIEW_JPG_ALLOWED_SIZES.append(size)
+
+            self.PREVIEW_JPG_RESTRICTED_SIZES = asbool(settings.get(
+                'preview.jpg.restricted_sizes', False
+            ))
+        if not self.PREVIEW_JPG_ALLOWED_SIZES:
+            size = PreviewSize(256, 256)
+            self.PREVIEW_JPG_ALLOWED_SIZES.append(size)
+
 
     def configure_filedepot(self):
         depot_storage_name = self.DEPOT_STORAGE_NAME
 
         TREEVIEW_FOLDERS = 'folders'
         TREEVIEW_ALL = 'all'
+
+
+class PreviewSize(object):
+
+    def __init__(self, width: int, height: int) -> None:
+        self.width = width
+        self.height = height

tracim/exceptions.py

 
 class RevisionDoesNotMatchThisContent(TracimException):
     pass
+
+
+class PageOfPreviewNotFound(NotFound):
+    pass
+
+class PreviewSizeNotAllowed(TracimException):
+    pass

tracim/lib/core/content.py

 from operator import itemgetter
 
 import transaction
+from preview_generator.manager import PreviewManager
 from sqlalchemy import func
 from sqlalchemy.orm import Query
 from depot.manager import DepotManager
 from tracim.lib.utils.utils import cmp_to_key
 from tracim.lib.core.notifications import NotifierFactory
 from tracim.exceptions import SameValueError
+from tracim.exceptions import PageOfPreviewNotFound
+from tracim.exceptions import PreviewSizeNotAllowed
 from tracim.exceptions import EmptyRawContentNotAllowed
 from tracim.exceptions import RevisionDoesNotMatchThisContent
 from tracim.exceptions import EmptyLabelNotAllowed
         self._show_all_type_of_contents_in_treeview = all_content_in_treeview
         self._force_show_all_types = force_show_all_types
         self._disable_user_workspaces_filter = disable_user_workspaces_filter
+        self.preview_manager = PreviewManager(self._config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
 
     @contextmanager
     def show(
             ),
         ))
 
+    def get_pdf_preview_path(
+            self,
+            content_id: int,
+            revision_id: int,
+            page: int
+    ) -> str:
+        """
+        Get pdf preview of revision of content
+        :param content_id: id of content
+        :param revision_id: id of content revision
+        :param page: page number of the preview, useful for multipage content
+        :return: preview_path as string
+        """
+        file_path = self.get_one_revision_filepath(revision_id)
+        if page >= self.preview_manager.get_page_nb(file_path):
+            raise PageOfPreviewNotFound(
+                'page {page} of content {content_id} does not exist'.format(
+                    page=page,
+                    content_id=content_id
+                ),
+            )
+        jpg_preview_path = self.preview_manager.get_jpeg_preview(
+            file_path,
+            page=page
+        )
+        return jpg_preview_path
+
+    def get_full_pdf_preview_path(self, revision_id: int) -> str:
+        """
+        Get full(multiple page) pdf preview of revision of content
+        :param revision_id: id of revision
+        :return: path of the full pdf preview of this revision
+        """
+        file_path = self.get_one_revision_filepath(revision_id)
+        pdf_preview_path = self.preview_manager.get_pdf_preview(file_path)
+        return pdf_preview_path
+
+    def get_jpg_preview_path(
+        self,
+        content_id: int,
+        revision_id: int,
+        page: int,
+        width: int = None,
+        height: int = None,
+    ) -> str:
+        """
+        Get jpg preview of revision of content
+        :param content_id: id of content
+        :param revision_id: id of content revision
+        :param page: page number of the preview, useful for multipage content
+        :param width: width in pixel
+        :param height: height in pixel
+        :return: preview_path as string
+        """
+        file_path = self.get_one_revision_filepath(revision_id)
+        if page >= self.preview_manager.get_page_nb(file_path):
+            raise Exception(
+                'page {page} of revision {revision_id} of content {content_id} does not exist'.format(  # nopep8
+                    page=page,
+                    revision_id=revision_id,
+                    content_id=content_id,
+                ),
+            )
+        if not width and not height:
+            width = self._config.PREVIEW_JPG_ALLOWED_SIZES[0].width
+            height = self._config.PREVIEW_JPG_ALLOWED_SIZES[0].height
+
+        allowed_size = False
+        for preview_size in self._config.PREVIEW_JPG_ALLOWED_SIZES:
+            if width == preview_size.width and height == preview_size.height:
+                allowed_size = True
+                break
+
+        if not allowed_size and self._config.PREVIEW_JPG_RESTRICTED_SIZES:
+            raise PreviewSizeNotAllowed(
+                'Size {width}x{height} is not allowed for jpeg preview'.format(
+                    width=width,
+                    height=height,
+                )
+            )
+        jpg_preview_path = self.preview_manager.get_jpeg_preview(
+            file_path,
+            page=page,
+            width=width,
+            height=height,
+        )
+        return jpg_preview_path
+
     def get_all(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> typing.List[Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
         assert content_type is not None# DYN_REMOVE

tracim/tests/__init__.py

             'depot_storage_dir': '/tmp/test/depot',
             'depot_storage_name': 'test',
             'preview_cache_dir': '/tmp/test/preview_cache',
+            'preview.jpg.restricted_sizes': True,
 
         }
         hapic.reset_context()

tracim/tests/functional/test_contents.py

 
     def test_api__get_sized_jpeg_preview__ok__200__nominal_case(self) -> None:
         """
-        Set one file of a content
+        get 256x256 preview of a txt file
         """
         dbsession = get_tm_session(self.session_factory, transaction.manager)
         admin = dbsession.query(models.User) \
 
     def test_api__get_full_pdf_preview__ok__200__nominal_case(self) -> None:
         """
-        Set one file of a content
+        get full pdf preview of a txt file
         """
         dbsession = get_tm_session(self.session_factory, transaction.manager)
         admin = dbsession.query(models.User) \
 
     def test_api__get_full_pdf_preview__err__400__png_UnavailablePreviewType(self) -> None:
         """
-        Set one file of a content
+       get full pdf preview of a png image -> error UnavailablePreviewType
         """
         dbsession = get_tm_session(self.session_factory, transaction.manager)
         admin = dbsession.query(models.User) \

tracim/views/contents_api/file_controller.py

 import typing
 
 import transaction
-from depot.io.local import LocalStoredFile
 from depot.manager import DepotManager
 from preview_generator.exception import UnavailablePreviewType
 from pyramid.config import Configurator
 from tracim.models.contents import ContentTypeLegacy as ContentType
 from tracim.models.contents import file_type
 from tracim.models.revision_protection import new_revision
-from preview_generator.manager import PreviewManager
 
 FILE_ENDPOINTS_TAG = 'Files'
 
     @hapic.output_file([])
     def preview_pdf(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             hapic_data.path.content_id,
             content_type=ContentType.Any
         )
-        file_path = api.get_one_revision_filepath(content.revision_id)
-        if hapic_data.query.page >= preview_manager.get_page_nb(file_path):
-            raise Exception('page {page} of content {content_id} does not exist'.format(
-                page=hapic_data.query.page,
-                content_id=content.content_id),
-            )
-        pdf_preview_path = preview_manager.get_pdf_preview(file_path, page=hapic_data.query.page)  # nopep8
+        pdf_preview_path = api.get_pdf_preview_path(
+            content.content_id,
+            content.revision_id,
+            page=hapic_data.query.page
+        )
         return FileResponse(pdf_preview_path)
 
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @hapic.output_file([])
     def preview_pdf_full(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             hapic_data.path.content_id,
             content_type=ContentType.Any
         )
-        file_path = api.get_one_revision_filepath(content.revision_id)
-        pdf_preview_path = preview_manager.get_pdf_preview(file_path)
+        pdf_preview_path = api.get_full_pdf_preview_path(content.revision_id)
         return FileResponse(pdf_preview_path)
 
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @hapic.output_file([])
     def preview_pdf_revision(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             revision_id=hapic_data.path.revision_id,
             content=content
         )
-        file_path = api.get_one_revision_filepath(revision.revision_id)
-        if hapic_data.query.page >= preview_manager.get_page_nb(file_path):
-            raise Exception('page {page} of content {content_id} does not exist'.format(
-                page=hapic_data.query.page,
-                content_id=content.content_id),
-            )
-        pdf_preview_path = preview_manager.get_pdf_preview(file_path, page=hapic_data.query.page)  # nopep8
+        pdf_preview_path = api.get_pdf_preview_path(
+            revision.content_id,
+            revision.revision_id,
+            page=hapic_data.query.page
+        )
         return FileResponse(pdf_preview_path)
 
     # jpg
     @hapic.output_file([])
     def preview_jpg(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             hapic_data.path.content_id,
             content_type=ContentType.Any
         )
-        file_path = api.get_one_revision_filepath(content.revision_id)
-        if hapic_data.query.page >= preview_manager.get_page_nb(file_path):
-            raise Exception('page {page} of content {content_id} does not exist'.format(
-                page=hapic_data.query.page,
-                content_id=content.content_id),
-            )
-        jpg_preview_path = preview_manager.get_jpeg_preview(file_path, page=hapic_data.query.page)  # nopep8
+        jpg_preview_path = api.get_jpg_preview_path(
+            content_id=content.content_id,
+            revision_id=content.revision_id,
+            page=hapic_data.query.page
+        )
         return FileResponse(jpg_preview_path)
 
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @hapic.output_file([])
     def sized_preview_jpg(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             hapic_data.path.content_id,
             content_type=ContentType.Any
         )
-        file_path = api.get_one_revision_filepath(content.revision_id)
-        if hapic_data.query.page >= preview_manager.get_page_nb(file_path):
-            raise Exception('page {page} of content {content_id} does not exist'.format(
-                page=hapic_data.query.page,
-                content_id=content.content_id),
-            )
-        jpg_preview_path = preview_manager.get_jpeg_preview(
-            file_path,
+        jpg_preview_path = api.get_jpg_preview_path(
+            content_id=content.content_id,
+            revision_id=content.revision_id,
             page=hapic_data.query.page,
-            width=hapic_data.path.width,
             height=hapic_data.path.height,
+            width=hapic_data.path.width,
         )
         return FileResponse(jpg_preview_path)
 
     @hapic.output_file([])
     def sized_preview_jpg_revision(self, context, request: TracimRequest, hapic_data=None):
         app_config = request.registry.settings['CFG']
-        preview_manager = PreviewManager(app_config.PREVIEW_CACHE_DIR, create_folder=True)  # nopep8
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
             revision_id=hapic_data.path.revision_id,
             content=content
         )
-        file_path = api.get_one_revision_filepath(revision.revision_id)
-        if hapic_data.query.page >= preview_manager.get_page_nb(file_path):
-            raise Exception('page {page} of content {content_id} does not exist'.format(
-                page=hapic_data.query.page,
-                content_id=content.content_id),
-            )
-        jpg_preview_path = preview_manager.get_jpeg_preview(
-            file_path,
+        jpg_preview_path = api.get_jpg_preview_path(
+            content_id=content.content_id,
+            revision_id=revision.revision_id,
             page=hapic_data.query.page,
-            width=hapic_data.path.width,
             height=hapic_data.path.height,
+            width=hapic_data.path.width,
         )
         return FileResponse(jpg_preview_path)