fix allowed_dims endpoint

tracim/config.py

         #     self.RADICALE_CLIENT_BASE_URL_HOST,
         #     self.RADICALE_CLIENT_BASE_URL_PREFIX,
         # )
-        preview_jpg_allowed_sizes_str = settings.get('preview.jpg.allowed_sizes', '')  # nopep8
-        allowed_size = []
-        if preview_jpg_allowed_sizes_str:
-            for sizes in preview_jpg_allowed_sizes_str.split(','):
+        self.PREVIEW_JPG_RESTRICTED_DIMS = asbool(settings.get(
+            'preview.jpg.restricted_dims', False
+        ))
+        preview_jpg_allowed_dims_str = settings.get('preview.jpg.allowed_dims', '')  # nopep8
+        allowed_dims = []
+        if preview_jpg_allowed_dims_str:
+            for sizes in preview_jpg_allowed_dims_str.split(','):
                 parts = sizes.split('x')
                 assert len(parts) == 2
                 width, height = parts
                 assert width.isdecimal()
                 assert height.isdecimal()
-                size = PreviewSize(int(width), int(height))
-                allowed_size.append(size)
+                size = PreviewDim(int(width), int(height))
+                allowed_dims.append(size)
 
-            self.PREVIEW_JPG_RESTRICTED_SIZES = asbool(settings.get(
-                'preview.jpg.restricted_sizes', False
-            ))
-        if not allowed_size:
-            size = PreviewSize(256, 256)
-            allowed_size.append(size)
+        if not allowed_dims:
+            size = PreviewDim(256, 256)
+            allowed_dims.append(size)
 
-        self.PREVIEW_JPG_ALLOWED_SIZES = allowed_size
+        self.PREVIEW_JPG_ALLOWED_DIMS = allowed_dims
 
     def configure_filedepot(self):
         depot_storage_name = self.DEPOT_STORAGE_NAME
         TREEVIEW_ALL = 'all'
 
 
-class PreviewSize(object):
+class PreviewDim(object):
 
     def __init__(self, width: int, height: int) -> None:
         self.width = width
         self.height = height
 
     def __repr__(self):
-        return "<PreviewSize width:{width} height:{height}>".format(
+        return "<PreviewDim width:{width} height:{height}>".format(
             width=self.width,
             height=self.height,
         )

tracim/exceptions.py

 class PageOfPreviewNotFound(NotFound):
     pass
 
-class PreviewSizeNotAllowed(TracimException):
-    pass
+
+class PreviewDimNotAllowed(TracimException):
+    pass

tracim/lib/core/content.py

 from sqlalchemy import or_
 from sqlalchemy.sql.elements import and_
 
+from tracim.config import PreviewDim
 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 PreviewDimNotAllowed
 from tracim.exceptions import EmptyRawContentNotAllowed
 from tracim.exceptions import RevisionDoesNotMatchThisContent
 from tracim.exceptions import EmptyLabelNotAllowed
 from tracim.models.data import UserRoleInWorkspace
 from tracim.models.data import Workspace
 from tracim.lib.utils.translation import fake_translator as _
-from tracim.models.context_models import RevisionInContext
+from tracim.models.context_models import RevisionInContext, \
+    PreviewAllowedDim
 from tracim.models.context_models import ContentInContext
 
 __author__ = 'damien'
         pdf_preview_path = self.preview_manager.get_pdf_preview(file_path)
         return pdf_preview_path
 
+    def get_jpg_preview_allowed_dim(self) -> PreviewAllowedDim:
+        return PreviewAllowedDim(
+            self._config.PREVIEW_JPG_RESTRICTED_DIMS,
+            self._config.PREVIEW_JPG_ALLOWED_DIMS,
+        )
     def get_jpg_preview_path(
         self,
         content_id: int,
                 ),
             )
         if not width and not height:
-            width = self._config.PREVIEW_JPG_ALLOWED_SIZES[0].width
-            height = self._config.PREVIEW_JPG_ALLOWED_SIZES[0].height
+            width = self._config.PREVIEW_JPG_ALLOWED_DIMS[0].width
+            height = self._config.PREVIEW_JPG_ALLOWED_DIMS[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
+        allowed_dim = False
+        for preview_dim in self._config.PREVIEW_JPG_ALLOWED_DIMS:
+            if width == preview_dim.width and height == preview_dim.height:
+                allowed_dim = True
                 break
 
-        if not allowed_size and self._config.PREVIEW_JPG_RESTRICTED_SIZES:
-            raise PreviewSizeNotAllowed(
+        if not allowed_dim and self._config.PREVIEW_JPG_RESTRICTED_DIMS:
+            raise PreviewDimNotAllowed(
                 'Size {width}x{height} is not allowed for jpeg preview'.format(
                     width=width,
                     height=height,

tracim/models/context_models.py

 from slugify import slugify
 from sqlalchemy.orm import Session
 from tracim import CFG
+from tracim.config import PreviewDim
 from tracim.models import User
 from tracim.models.auth import Profile
 from tracim.models.data import Content
 from tracim.models.contents import ContentTypeLegacy as ContentType
 
 
+class PreviewAllowedDim(object):
+
+    def __init__(
+            self,
+            restricted:bool,
+            dimensions: typing.List[PreviewDim]
+    ) -> None:
+        self.restricted = restricted
+        self.dimensions = dimensions
+
+
 class MoveParams(object):
     """
     Json body params for move action model

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,
+            'preview.jpg.restricted_dims': True,
 
         }
         hapic.reset_context()

tracim/tests/functional/test_contents.py

         assert res.content_type == 'image/png'
         assert res.content_length == len(image.getvalue())
 
+    def test_api__get_allowed_size_dim__ok__nominal_case(self) -> None:
+        dbsession = get_tm_session(self.session_factory, transaction.manager)
+        admin = dbsession.query(models.User) \
+            .filter(models.User.email == 'admin@admin.admin') \
+            .one()
+        workspace_api = WorkspaceApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        business_workspace = workspace_api.get_one(1)
+        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        test_file = content_api.create(
+            content_type=ContentType.File,
+            workspace=business_workspace,
+            parent=tool_folder,
+            label='Test file',
+            do_save=False,
+            do_notify=False,
+        )
+        test_file.file_extension = '.txt'
+        test_file.depot_file = FileIntent(
+            b'Test file',
+            'Test_file.txt',
+            'text/plain',
+        )
+        dbsession.flush()
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        content_id = int(test_file.content_id)
+        res = self.testapp.get(
+            '/api/v2/workspaces/1/files/{}/preview/jpg/allowed_dims'.format(content_id),
+            status=200,
+        )
+        res = res.json_body
+        assert res['restricted'] == True
+        assert len(res['dimensions']) == 1
+        dim = res['dimensions'][0]
+        assert dim['width'] == 256
+        assert dim['height'] == 256
+
     def test_api__get_jpeg_preview__ok__200__nominal_case(self) -> None:
         """
         Set one file of a content
         new_image = Image.open(io.BytesIO(res.body))
         assert 256, 256 == new_image.size
 
+    def test_api__get_sized_jpeg_preview__err__400__SizeNotAllowed(self) -> None:
+        """
+        get 256x256 preview of a txt file
+        """
+        dbsession = get_tm_session(self.session_factory, transaction.manager)
+        admin = dbsession.query(models.User) \
+            .filter(models.User.email == 'admin@admin.admin') \
+            .one()
+        workspace_api = WorkspaceApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        business_workspace = workspace_api.get_one(1)
+        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        test_file = content_api.create(
+            content_type=ContentType.File,
+            workspace=business_workspace,
+            parent=tool_folder,
+            label='Test file',
+            do_save=True,
+            do_notify=False,
+        )
+        dbsession.flush()
+        transaction.commit()
+        content_id = int(test_file.content_id)
+        image = create_test_image()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        res = self.testapp.put(
+            '/api/v2/workspaces/1/files/{}/raw'.format(content_id),
+            upload_files=[
+                ('files',image.name, image.getvalue())
+            ],
+            status=204,
+        )
+        res = self.testapp.get(
+            '/api/v2/workspaces/1/files/{}/preview/jpg/512x512'.format(content_id),  # nopep8
+            status=400
+        )
+
     def test_api__get_sized_jpeg_revision_preview__ok__200__nominal_case(self) -> None:
         """
         get 256x256 revision preview of a txt file

tracim/views/contents_api/file_controller.py

 from pyramid.config import Configurator
 from pyramid.response import FileResponse, FileIter
 
-from tracim.exceptions import EmptyLabelNotAllowed
-from tracim.models.data import UserRoleInWorkspace
-
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
 from tracim.lib.core.content import ContentApi
 from tracim.views.controllers import Controller
 from tracim.views.core_api.schemas import FileContentSchema
+from tracim.views.core_api.schemas import AllowedJpgPreviewDimSchema
 from tracim.views.core_api.schemas import ContentPreviewSizedPathSchema
 from tracim.views.core_api.schemas import RevisionPreviewSizedPathSchema
 from tracim.views.core_api.schemas import PageQuerySchema
 from tracim.views.core_api.schemas import NoContentSchema
 from tracim.lib.utils.authorization import require_content_types
 from tracim.lib.utils.authorization import require_workspace_role
+from tracim.models.data import UserRoleInWorkspace
 from tracim.models.context_models import ContentInContext
 from tracim.models.context_models import RevisionInContext
 from tracim.models.contents import ContentTypeLegacy as ContentType
 from tracim.models.contents import file_type
 from tracim.models.revision_protection import new_revision
+from tracim.exceptions import EmptyLabelNotAllowed
+from tracim.exceptions import PreviewDimNotAllowed
 
 FILE_ENDPOINTS_TAG = 'Files'
 
             hapic_data.path.content_id,
             content_type=ContentType.Any
         )
+        allowed_dim = api.get_jpg_preview_allowed_dim()
         jpg_preview_path = api.get_jpg_preview_path(
             content_id=content.content_id,
             revision_id=content.revision_id,
-            page=hapic_data.query.page
+            page=hapic_data.query.page,
+            width=allowed_dim.dimensions[0].width,
+            height=allowed_dim.dimensions[0].height,
         )
         return FileResponse(jpg_preview_path)
 
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([file_type])
+    @hapic.handle_exception(PreviewDimNotAllowed, HTTPStatus.BAD_REQUEST)
     @hapic.input_query(PageQuerySchema())
     @hapic.input_path(ContentPreviewSizedPathSchema())
     @hapic.output_file([])
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([file_type])
+    @hapic.handle_exception(PreviewDimNotAllowed, HTTPStatus.BAD_REQUEST)
     @hapic.input_path(RevisionPreviewSizedPathSchema())
     @hapic.input_query(PageQuerySchema())
     @hapic.output_file([])
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([file_type])
-    @hapic.output_file([])
+    @hapic.input_path(WorkspaceAndContentIdPathSchema())
+    @hapic.output_body(AllowedJpgPreviewDimSchema())
     def allowed_dim_preview_jpg(self, context, request: TracimRequest, hapic_data=None):
-        raise NotImplemented()
+        app_config = request.registry.settings['CFG']
+        api = ContentApi(
+            current_user=request.current_user,
+            session=request.dbsession,
+            config=app_config,
+        )
+        return api.get_jpg_preview_allowed_dim()
 
     # File infos
     @hapic.with_api_doc(tags=[FILE_ENDPOINTS_TAG])

tracim/views/core_api/schemas.py

     height = marshmallow.fields.Int(example=256)
 
 
+class AllowedJpgPreviewSizesSchema(marshmallow.Schema):
+    width = marshmallow.fields.Int(example=256)
+    height = marshmallow.fields.Int(example=256)
+
+
+class AllowedJpgPreviewDimSchema(marshmallow.Schema):
+    restricted = marshmallow.fields.Bool()
+    dimensions = marshmallow.fields.Nested(
+        AllowedJpgPreviewSizesSchema,
+        many=True
+    )
+
+
 class WorkspaceAndContentRevisionIdPathSchema(
     WorkspaceIdPathSchema,
     ContentIdPathSchema,