Merge pull request #270 from tracim/dev/232/preview_generator

bin/tg2env-patch

-#!/usr/bin/python
-
-import os
-import sys
-
-# Go to parent folder
-
-def usage():
-    print('')
-    print('USAGE: '+__file__+' <step_1_or2> <site_packages_folder_path> ')
-    print('')
-    print('')
-
-
-def show_help_and_exit():
-    usage()
-    exit()
-
-def on_result_and_exit(error_code):
-    if error_code==0:
-        print('')
-        print('')
-        exit(0)
-    
-    print('ERRROR')
-    print('')
-    print('')
-    exit(error_code)
-
-#######
-
-
-if len(sys.argv)<=2:
-    show_help_and_exit()
-
-########################################
-#
-# BELOW ARE STANDARD ACTIONS
-#
-########################################
-
-patch_step = sys.argv[1]
-sitepackages_path = sys.argv[2]
-
-print('PATCHING PYTHON CODE')
-print('--------------------')
-print('site packages path:    %s'%(sitepackages_path))
-print('')
-
-if patch_step=='1':
-
-    patchable_paths = [
-        sitepackages_path+'/tgext/pluggable',
-        sitepackages_path+'/resetpassword',
-        sitepackages_path+'/babel'
-    ]
-
-    for patchable_path in patchable_paths:
-        print('2to3 conversion for %s...' % (patchable_path))
-        os.system('2to3 -w %s'%(patchable_path))
-        print('-> done')
-
-    babel_source_code_patch_content = """--- tg2env/lib/python3.2/site-packages/babel/messages/pofile.py 2014-11-07 15:35:14.039913184 +0100
-    +++ tg2env/lib/python3.2/site-packages/babel/messages/pofile.py 2014-10-30 17:37:36.295091573 +0100
-    @@ -384,8 +384,13 @@
-     
-         def _write(text):
-             if isinstance(text, text_type):
-    -            text = text.encode(catalog.charset, 'backslashreplace')
-    -        fileobj.write(text)
-    +            pass
-    +            # text = text.encode(catalog.charset, 'backslashreplace')
-    +        try:
-    +            fileobj.write(text.encode('UTF-8'))
-    +        except Exception as e:
-    +            fileobj.write(text)
-    +        
-     
-         def _write_comment(comment, prefix=''):
-             # xgettext always wraps comments even if --no-wrap is passed;
-    """
-
-    babel_patchable_file_path = sitepackages_path+'/babel/messages/pofile.py'
-    print('Patching code in file %s...'%(babel_patchable_file_path))
-    os.system('echo "%s"|patch -p1 %s'%(babel_source_code_patch_content, babel_patchable_file_path))
-    print('-> done')
-
-elif patch_step=='2':
-    resetpassword_patchable_file_path = sitepackages_path+'/resetpassword/lib/__init__.py'
-    print('Patching code in file %s...'%(resetpassword_patchable_file_path))
-    os.system("sed -i 's/body\.encode/body/g' %s" % (resetpassword_patchable_file_path))
-    print('-> done')
-
-else:
-    show_help_and_exit()
-
-print('')
-print('')
-
-

tracim/development.ini.base

 # You can set french as default language by uncommenting next line
 # lang = fr
 cache_dir = %(here)s/data
+preview_cache_dir = /tmp/tracim/cache/previews/
 beaker.session.key = tracim
 beaker.session.secret = 3283411b-1904-4554-b0e1-883863b53080
 

tracim/migration/versions/69fb10c3d6f0_files_on_disk.py

+"""files on disk
+
+Revision ID: 69fb10c3d6f0
+Revises: c1cea4bbae16
+Create Date: 2017-06-07 17:25:47.306472
+
+"""
+
+from alembic import op
+from depot.fields.sqlalchemy import UploadedFileField
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '69fb10c3d6f0'
+down_revision = 'c1cea4bbae16'
+
+
+def upgrade():
+    op.add_column('content_revisions',
+                  sa.Column('depot_file',
+                            UploadedFileField))
+
+
+def downgrade():
+    op.drop_column('content_revisions', 'depot_file')

tracim/setup.py

     "unicode-slugify==0.1.3",
     "pytz==2014.7",
     'rq==0.7.1',
+    'filedepot>=0.5.0',
+    'preview-generator'
     ]
 
 setup(

tracim/tracim/config/app_cfg.py

 from tracim.model.data import ActionDescription
 from tracim.model.data import ContentType
 
+from depot.manager import DepotManager
+DepotManager.configure(
+    'default',
+    {'depot.storage_path': '/tmp/depot_storage_path/'}
+)
+
 base_config = TracimAppConfig()
 base_config.renderers = []
 base_config.use_toscawidgets = False
 
     def __init__(self):
 
+        self.PREVIEW_CACHE = str(tg.config.get('preview_cache_dir'))
+
         self.DATA_UPDATE_ALLOWED_DURATION = int(tg.config.get('content.update.allowed.duration', 0))
 
         self.WEBSITE_TITLE = tg.config.get('website.title', 'TRACIM')

tracim/tracim/controllers/content.py

 # -*- coding: utf-8 -*-
+from tracim.config.app_cfg import CFG
+
 __author__ = 'damien'
 
 import sys
 import traceback
 
 from cgi import FieldStorage
+from depot.manager import DepotManager
+from preview_generator.manager import PreviewManager
+from sqlalchemy.orm.exc import NoResultFound
 import tg
+from tg import abort
 from tg import tmpl_context
 from tg import require
 from tg import predicates
 from tg.i18n import ugettext as _
 from tg.predicates import not_anonymous
-from sqlalchemy.orm.exc import NoResultFound
-from tg import abort
 
 from tracim.controllers import TIMRestController
 from tracim.controllers import StandardController
 from tracim.lib import CST
 from tracim.lib.base import BaseController
 from tracim.lib.base import logger
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
 from tracim.lib.utils import SameValueError
 from tracim.lib.utils import get_valid_header_file_name
 from tracim.lib.utils import str_as_bool
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
-from tracim.lib.integrity import render_invalid_integrity_chosen_path
 
 
 class UserWorkspaceFolderThreadCommentRestController(TIMRestController):
 
     @tg.expose()
     @tg.require(current_user_is_contributor())
-    def post(self, content=''):
+    def post(self, content: str = ''):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
         thread = tmpl_context.thread
 
-
         api = ContentApi(tmpl_context.current_user)
 
         comment = api.create_comment(workspace, thread, content, True)
-
-        next_url = tg.url('/workspaces/{}/folders/{}/threads/{}').format(tmpl_context.workspace_id,
-                                                                              tmpl_context.folder_id,
-                                                                              tmpl_context.thread_id)
+        next_str = '/workspaces/{}/folders/{}/threads/{}'
+        next_url = tg.url(next_str).format(tmpl_context.workspace_id,
+                                           tmpl_context.folder_id,
+                                           tmpl_context.thread_id)
         tg.flash(_('Comment added'), CST.STATUS_OK)
         tg.redirect(next_url)
 
         # TODO - CHECK RIGHTS
         item_id = int(item_id)
         content_api = ContentApi(tmpl_context.current_user)
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
-
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
+        next_or_back = '/workspaces/{}/folders/{}/threads/{}'
         try:
-
-            next_url = tg.url('/workspaces/{}/folders/{}/threads/{}').format(tmpl_context.workspace_id,
-                                                                             tmpl_context.folder_id,
-                                                                             tmpl_context.thread_id)
-            undo_url = tg.url('/workspaces/{}/folders/{}/threads/{}/comments/{}/put_delete_undo').format(tmpl_context.workspace_id,
-                                                                                                         tmpl_context.folder_id,
-                                                                                                         tmpl_context.thread_id,
-                                                                                                         item_id)
-
-            msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
+            next_url = tg.url(next_or_back).format(tmpl_context.workspace_id,
+                                                   tmpl_context.folder_id,
+                                                   tmpl_context.thread_id)
+            undo_str = '{}/comments/{}/put_delete_undo'
+            undo_url = tg.url(undo_str).format(next_url,
+                                               item_id)
+            msg_str = ('{} deleted. '
+                       '<a class="alert-link" href="{}">Cancel action</a>')
+            msg = _(msg_str).format(self._item_type_label,
+                                    undo_url)
             with new_revision(item):
                 content_api.delete(item)
                 content_api.save(item, ActionDescription.DELETION)
             tg.redirect(next_url)
 
         except ValueError as e:
-            back_url = tg.url('/workspaces/{}/folders/{}/threads/{}').format(tmpl_context.workspace_id,
-                                                                             tmpl_context.folder_id,
-                                                                             tmpl_context.thread_id)
+            back_url = tg.url(next_or_back).format(tmpl_context.workspace_id,
+                                                   tmpl_context.folder_id,
+                                                   tmpl_context.thread_id)
             msg = _('{} not deleted: {}').format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
 
-
     @tg.expose()
     @tg.require(not_anonymous())
     def put_delete_undo(self, item_id):
         require_current_user_is_owner(int(item_id))
 
         item_id = int(item_id)
-        content_api = ContentApi(tmpl_context.current_user, True, True) # Here we do not filter deleted items
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+        # Here we do not filter deleted items
+        content_api = ContentApi(tmpl_context.current_user, True, True)
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
+        next_or_back = '/workspaces/{}/folders/{}/threads/{}'
         try:
-            next_url = tg.url('/workspaces/{}/folders/{}/threads/{}').format(tmpl_context.workspace_id,
-                                                                             tmpl_context.folder_id,
-                                                                             tmpl_context.thread_id)
+            next_url = tg.url(next_or_back).format(tmpl_context.workspace_id,
+                                                   tmpl_context.folder_id,
+                                                   tmpl_context.thread_id)
             msg = _('{} undeleted.').format(self._item_type_label)
             with new_revision(item):
                 content_api.undelete(item)
 
         except ValueError as e:
             logger.debug(self, 'Exception: {}'.format(e.__str__))
-            back_url = tg.url('/workspaces/{}/folders/{}/threads/{}').format(tmpl_context.workspace_id,
-                                                                             tmpl_context.folder_id,
-                                                                             tmpl_context.thread_id)
-            msg = _('{} not un-deleted: {}').format(self._item_type_label, str(e))
+            back_url = tg.url(next_or_back).format(tmpl_context.workspace_id,
+                                                   tmpl_context.folder_id,
+                                                   tmpl_context.thread_id)
+            msg = _('{} not un-deleted: {}').format(self._item_type_label,
+                                                    str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
 
     @tg.expose('tracim.templates.file.getone')
     def get_one(self, file_id, revision_id=None):
         file_id = int(file_id)
+        cache_path = CFG.get_instance().PREVIEW_CACHE
+        preview_manager = PreviewManager(cache_path, create_folder=True)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
-
         current_user_content = Context(CTX.CURRENT_USER,
                                        current_user=user).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
-
-        content_api = ContentApi(
-            user,
-            show_archived=True,
-            show_deleted=True,
-        )
+        content_api = ContentApi(user,
+                                 show_archived=True,
+                                 show_deleted=True)
         if revision_id:
-            file = content_api.get_one_from_revision(file_id,  self._item_type, workspace, revision_id)
+            file = content_api.get_one_from_revision(file_id,
+                                                     self._item_type,
+                                                     workspace,
+                                                     revision_id)
         else:
-            file = content_api.get_one(file_id, self._item_type, workspace)
+            file = content_api.get_one(file_id,
+                                       self._item_type,
+                                       workspace)
+            revision_id = file.revision_id
+
+        file_path = content_api.get_one_revision_filepath(revision_id)
+        nb_page = preview_manager.get_nb_page(file_path=file_path)
+        preview_urls = []
+        for page in range(int(nb_page)):
+            url_str = '/previews/{}/pages/{}?revision_id={}'
+            url = url_str.format(file_id,
+                                 page,
+                                 revision_id)
+            preview_urls.append(url)
 
         fake_api_breadcrumb = self.get_breadcrumb(file_id)
-        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb, current_user=current_user_content)
+        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb,
+                                         current_user=current_user_content)
         fake_api = Context(CTX.FOLDER,
                            current_user=user).toDict(fake_api_content)
-
         dictified_file = Context(self._get_one_context,
                                  current_user=user).toDict(file, 'file')
-        return DictLikeClass(result = dictified_file, fake_api=fake_api)
+        result = DictLikeClass(result=dictified_file,
+                               fake_api=fake_api,
+                               nb_page=nb_page,
+                               url=preview_urls)
+        return result
 
     @tg.require(current_user_is_reader())
     @tg.expose()
     def download(self, file_id, revision_id=None):
         file_id = int(file_id)
-        revision_id = int(revision_id) if revision_id!='latest' else None
+        revision_id = int(revision_id) if revision_id != 'latest' else None
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
 
         content_api = ContentApi(user)
         revision_to_send = None
         if revision_id:
-            item = content_api.get_one_from_revision(file_id,  self._item_type, workspace, revision_id)
+            item = content_api.get_one_from_revision(file_id,
+                                                     self._item_type,
+                                                     workspace,
+                                                     revision_id)
         else:
-            item = content_api.get_one(file_id, self._item_type, workspace)
+            item = content_api.get_one(file_id,
+                                       self._item_type,
+                                       workspace)
 
         revision_to_send = None
-        if item.revision_to_serialize<=0:
+        if item.revision_to_serialize <= 0:
             for revision in item.revisions:
                 if not revision_to_send:
                     revision_to_send = revision
 
-                if revision.revision_id>revision_to_send.revision_id:
+                if revision.revision_id > revision_to_send.revision_id:
                     revision_to_send = revision
         else:
             for revision in item.revisions:
-                if revision.revision_id==item.revision_to_serialize:
+                if revision.revision_id == item.revision_to_serialize:
                     revision_to_send = revision
                     break
 
         content_type = 'application/x-download'
         if revision_to_send.file_mimetype:
             content_type = str(revision_to_send.file_mimetype)
-            tg.response.headers['Content-type'] = str(revision_to_send.file_mimetype)
+            tg.response.headers['Content-type'] = \
+                str(revision_to_send.file_mimetype)
 
         tg.response.headers['Content-Type'] = content_type
         file_name = get_valid_header_file_name(revision_to_send.file_name)
         tg.response.headers['Content-Disposition'] = \
             str('attachment; filename="{}"'.format(file_name))
-        return revision_to_send.file_content
+        return DepotManager.get().get(revision_to_send.depot_file)
 
-
-    def get_all_fake(self, context_workspace: Workspace, context_folder: Content):
+    def get_all_fake(self,
+                     context_workspace: Workspace,
+                     context_folder: Content):
         """
-        fake methods are used in other controllers in order to simulate a client/server api.
-        the "client" controller method will include the result into its own fake_api object
-        which will be available in the templates
-
-        :param context_workspace: the workspace which would be taken from tmpl_context if we were in the normal behavior
+        fake methods are used in other controllers in order to simulate a
+        client/server api.  the "client" controller method will include the
+        result into its own fake_api object which will be available in the
+        templates
+
+        :param context_workspace: the workspace which would be taken from
+                                  tmpl_context if we were in the normal
+                                  behavior
         :return:
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        files = content_api.get_all(context_folder.content_id, ContentType.File, workspace)
+        files = content_api.get_all(context_folder.content_id,
+                                    ContentType.File,
+                                    workspace)
 
         dictified_files = Context(CTX.FILES).toDict(files)
-        return DictLikeClass(result = dictified_files)
-
+        return DictLikeClass(result=dictified_files)
 
     @tg.require(current_user_is_contributor())
     @tg.expose()
         api = ContentApi(tmpl_context.current_user)
         with DBSession.no_autoflush:
             file = api.create(ContentType.File, workspace, folder, label)
-            api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
-
+            api.update_file_data(file,
+                                 file_data.filename,
+                                 file_data.type,
+                                 file_data.file.read())
             # Display error page to user if chosen label is in conflict
             if not self._path_validation.validate_new_content(file):
                 return render_invalid_integrity_chosen_path(
         api.save(file, ActionDescription.CREATION)
 
         tg.flash(_('File created'), CST.STATUS_OK)
-        tg.redirect(tg.url('/workspaces/{}/folders/{}/files/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, file.content_id))
-
+        redirect = '/workspaces/{}/folders/{}/files/{}'
+        tg.redirect(tg.url(redirect).format(tmpl_context.workspace_id,
+                                            tmpl_context.folder_id,
+                                            file.content_id))
 
     @tg.require(current_user_is_contributor())
     @tg.expose()
 
                     api.save(updated_item, ActionDescription.EDITION)
 
-                    # This case is the default "file title and description update"
-                    # In this case the file itself is not revisionned
+                    # This case is the default "file title and description
+                    # update" In this case the file itself is not revisionned
 
                 else:
                     # So, now we may have a comment and/or a file revision
-                    if comment and ''==label:
+                    if comment and '' == label:
                         comment_item = api.create_comment(workspace,
                                                           item, comment,
                                                           do_save=False)
                             # The notification is only sent
                             # if the file is NOT updated
                             #
-                            #  If the file is also updated,
-                            #  then a 'file revision' notification will be sent.
+                            # If the file is also updated,
+                            # then a 'file revision' notification will be sent.
                             api.save(comment_item,
                                      ActionDescription.COMMENT,
                                      do_notify=False)
 
                     if isinstance(file_data, FieldStorage):
-                        api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
+                        api.update_file_data(item,
+                                             file_data.filename,
+                                             file_data.type,
+                                             file_data.file.read())
 
                         # Display error page to user if chosen label is in
                         # conflict
 
             msg = _('{} updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
-            tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item.content_id))
+            tg.redirect(self._std_url.format(tmpl_context.workspace_id,
+                                             tmpl_context.folder_id,
+                                             item.content_id))
 
         except ValueError as e:
-            msg = _('{} not updated - error: {}').format(self._item_type_label, str(e))
+            error = '{} not updated - error: {}'
+            msg = _(error).format(self._item_type_label,
+                                  str(e))
             tg.flash(msg, CST.STATUS_ERROR)
-            tg.redirect(self._err_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item_id))
-
+            tg.redirect(self._err_url.format(tmpl_context.workspace_id,
+                                             tmpl_context.folder_id,
+                                             item_id))
 
 
 class UserWorkspaceFolderPageRestController(TIMWorkspaceContentRestController):
         page_id = int(page_id)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
-        workspace_id = tmpl_context.workspace_id
 
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
             show_archived=True,
         )
         if revision_id:
-            page = content_api.get_one_from_revision(page_id, ContentType.Page, workspace, revision_id)
+            page = content_api.get_one_from_revision(page_id,
+                                                     ContentType.Page,
+                                                     workspace,
+                                                     revision_id)
         else:
-            page = content_api.get_one(page_id, ContentType.Page, workspace)
+            page = content_api.get_one(page_id,
+                                       ContentType.Page,
+                                       workspace)
 
         fake_api_breadcrumb = self.get_breadcrumb(page_id)
-        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb, current_user=current_user_content)
+        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb,
+                                         current_user=current_user_content)
         fake_api = Context(CTX.FOLDER).toDict(fake_api_content)
 
         dictified_page = Context(CTX.PAGE).toDict(page, 'page')
-        return DictLikeClass(result = dictified_page, fake_api=fake_api)
-
+        return DictLikeClass(result=dictified_page,
+                             fake_api=fake_api)
 
-    def get_all_fake(self, context_workspace: Workspace, context_folder: Content):
+    def get_all_fake(self,
+                     context_workspace: Workspace,
+                     context_folder: Content):
         """
-        fake methods are used in other controllers in order to simulate a client/server api.
-        the "client" controller method will include the result into its own fake_api object
-        which will be available in the templates
 
-        :param context_workspace: the workspace which would be taken from tmpl_context if we were in the normal behavior
+        fake methods are used in other controllers in order to simulate a
+        client/server api.  the "client" controller method will include the
+        result into its own fake_api object which will be available in the
+        templates
+
+        :param context_workspace: the workspace which would be taken from
+                                  tmpl_context if we were in the normal
+                                  behavior
         :return:
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        pages = content_api.get_all(context_folder.content_id, ContentType.Page, workspace)
+        pages = content_api.get_all(context_folder.content_id,
+                                    ContentType.Page,
+                                    workspace)
 
         dictified_pages = Context(CTX.PAGES).toDict(pages)
-        return DictLikeClass(result = dictified_pages)
-
+        return DictLikeClass(result=dictified_pages)
 
     @tg.require(current_user_is_contributor())
     @tg.expose()
         api = ContentApi(tmpl_context.current_user)
 
         with DBSession.no_autoflush:
-            page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
+            page = api.create(ContentType.Page,
+                              workspace,
+                              tmpl_context.folder,
+                              label)
             page.description = content
 
             if not self._path_validation.validate_new_content(page):
         api.save(page, ActionDescription.CREATION, do_notify=True)
 
         tg.flash(_('Page created'), CST.STATUS_OK)
-        tg.redirect(tg.url('/workspaces/{}/folders/{}/pages/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, page.content_id))
-
+        redirect = '/workspaces/{}/folders/{}/pages/{}'
+        tg.redirect(tg.url(redirect).format(tmpl_context.workspace_id,
+                                            tmpl_context.folder_id,
+                                            page.content_id))
 
     @tg.require(current_user_is_contributor())
     @tg.expose()
-    def put(self, item_id, label='',content=''):
+    def put(self, item_id, label='', content=''):
         # INFO - D.A. This method is a raw copy of
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
 
             msg = _('{} updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
-            tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item.content_id))
-
+            tg.redirect(self._std_url.format(tmpl_context.workspace_id,
+                                             tmpl_context.folder_id,
+                                             item.content_id))
         except SameValueError as e:
-            msg = _('{} not updated: the content did not change').format(self._item_type_label)
+            not_updated = '{} not updated: the content did not change'
+            msg = _(not_updated).format(self._item_type_label)
             tg.flash(msg, CST.STATUS_WARNING)
-            tg.redirect(self._err_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item_id))
-
+            tg.redirect(self._err_url.format(tmpl_context.workspace_id,
+                                             tmpl_context.folder_id,
+                                             item_id))
         except ValueError as e:
-            msg = _('{} not updated - error: {}').format(self._item_type_label, str(e))
+            not_updated = '{} not updated - error: {}'
+            msg = _(not_updated).format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
-            tg.redirect(self._err_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item_id))
+            tg.redirect(self._err_url.format(tmpl_context.workspace_id,
+                                             tmpl_context.folder_id,
+                                             item_id))
 
 
 class UserWorkspaceFolderThreadRestController(TIMWorkspaceContentRestController):
     def _item_type(self):
         return ContentType.Thread
 
-
     @property
     def _item_type_label(self):
         return _('Thread')
 
-
     @property
     def _get_one_context(self) -> str:
         return CTX.THREAD
     @tg.expose()
     def post(self, label='', content='', parent_id=None):
         """
-        Creates a new thread. Actually, on POST, the content will be included in a user comment instead of being the thread description
+        Creates a new thread. Actually, on POST, the content will be included
+        in a user comment instead of being the thread description
         :param label:
         :param content:
         :return:
         api = ContentApi(tmpl_context.current_user)
 
         with DBSession.no_autoflush:
-            thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
-            # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
+            thread = api.create(ContentType.Thread,
+                                workspace,
+                                tmpl_context.folder,
+                                label)
+            # FIXME - DO NOT DUPLCIATE FIRST MESSAGE
+            # thread.description = content
             api.save(thread, ActionDescription.CREATION, do_notify=False)
 
             comment = api.create(ContentType.Comment, workspace, thread, label)
         api.do_notify(thread)
 
         tg.flash(_('Thread created'), CST.STATUS_OK)
-        tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, thread.content_id))
-
+        tg.redirect(self._std_url.format(tmpl_context.workspace_id,
+                                         tmpl_context.folder_id,
+                                         thread.content_id))
 
     @tg.require(current_user_is_reader())
     @tg.expose('tracim.templates.thread.getone')
         thread = content_api.get_one(thread_id, ContentType.Thread, workspace)
 
         fake_api_breadcrumb = self.get_breadcrumb(thread_id)
-        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb, current_user=current_user_content)
+        fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb,
+                                         current_user=current_user_content)
         fake_api = Context(CTX.FOLDER).toDict(fake_api_content)
 
         dictified_thread = Context(CTX.THREAD).toDict(thread, 'thread')
 
         if inverted:
-          dictified_thread.thread.history = reversed(dictified_thread.thread.history)
+            dictified_thread.thread.history = \
+                reversed(dictified_thread.thread.history)
 
         return DictLikeClass(
             result=dictified_thread,
         )
 
 
-
-class ItemLocationController(TIMWorkspaceContentRestController, BaseController):
+class ItemLocationController(TIMWorkspaceContentRestController,
+                             BaseController):
 
     @tg.require(current_user_is_content_manager())
     @tg.expose()
         raise NotImplementedError
         return item
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose('tracim.templates.folder.move')
     def edit(self, item_id):
         :param item_id:
         :return:
         """
-        current_user_content = Context(CTX.CURRENT_USER).toDict(tmpl_context.current_user)
-        fake_api = Context(CTX.FOLDER).toDict(DictLikeClass(current_user=current_user_content))
+        current_user_content = \
+            Context(CTX.CURRENT_USER).toDict(tmpl_context.current_user)
+        fake_api = \
+            Context(CTX.FOLDER) \
+            .toDict(DictLikeClass(current_user=current_user_content))
 
         item_id = int(item_id)
         user = tmpl_context.current_user
         item = content_api.get_one(item_id, ContentType.Any, workspace)
 
         dictified_item = Context(CTX.DEFAULT).toDict(item, 'item')
-        return DictLikeClass(result = dictified_item, fake_api=fake_api)
+        return DictLikeClass(result=dictified_item, fake_api=fake_api)
 
     @tg.require(current_user_is_content_manager())
     @tg.expose()
     def put(self, item_id, folder_id='0'):
         """
         :param item_id:
-        :param folder_id: id of the folder, in a style like 'workspace_14__content_1586'
+        :param folder_id: id of the folder, in a style like
+                          'workspace_14__content_1586'
         :return:
         """
         # TODO - SECURE THIS
                 api.move(item, new_parent)
             next_url = self.parent_controller.url(item_id)
             if new_parent:
-                tg.flash(_('Item moved to {}').format(new_parent.label), CST.STATUS_OK)
+                tg.flash(_('Item moved to {}').format(new_parent.label),
+                         CST.STATUS_OK)
             else:
                 tg.flash(_('Item moved to workspace root'))
 
             tg.redirect(next_url)
 
 
-
 class UserWorkspaceFolderRestController(TIMRestControllerWithBreadcrumb):
 
     TEMPLATE_NEW = 'mako:tracim.templates.folder.new'
         folder = content_api.get_one(folder_id, ContentType.Folder, workspace)
 
         dictified_folder = Context(CTX.FOLDER).toDict(folder, 'folder')
-        return DictLikeClass(result = dictified_folder)
-
+        return DictLikeClass(result=dictified_folder)
 
     @tg.require(current_user_is_reader())
     @tg.expose('tracim.templates.folder.getone')
             )
 
         fake_api_breadcrumb = self.get_breadcrumb(folder_id)
-        fake_api_subfolders = self.get_all_fake(workspace, folder.content_id).result
+        fake_api_subfolders = self.get_all_fake(workspace,
+                                                folder.content_id).result
         fake_api_pages = self.pages.get_all_fake(workspace, folder).result
         fake_api_files = self.files.get_all_fake(workspace, folder).result
         fake_api_threads = self.threads.get_all_fake(workspace, folder).result
             show_archived=show_archived,
         )
 
-
     def get_all_fake(self, context_workspace: Workspace, parent_id=None):
         """
-        fake methods are used in other controllers in order to simulate a client/server api.
-        the "client" controller method will include the result into its own fake_api object
-        which will be available in the templates
-
-        :param context_workspace: the workspace which would be taken from tmpl_context if we were in the normal behavior
+        fake methods are used in other controllers in order to simulate a
+        client/server api.  the "client" controller method will include the
+        result into its own fake_api object which will be available in the
+        templates
+
+        :param context_workspace: the workspace which would be taken from
+                                  tmpl_context if we were in the normal
+                                  behavior
         :return:
         """
         workspace = context_workspace
         folders = content_api.get_child_folders(parent_folder, workspace)
 
         folders = Context(CTX.FOLDERS).toDict(folders)
-        return DictLikeClass(result = folders)
-
+        return DictLikeClass(result=folders)
 
     @tg.require(current_user_is_content_manager())
     @tg.expose()
-    def post(self, label, parent_id=None, can_contain_folders=False, can_contain_threads=False, can_contain_files=False, can_contain_pages=False):
+    def post(self,
+             label,
+             parent_id=None,
+             can_contain_folders=False,
+             can_contain_threads=False,
+             can_contain_files=False,
+             can_contain_pages=False):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
 
         redirect_url_tmpl = '/workspaces/{}/folders/{}'
         redirect_url = ''
 
-
         try:
             parent = None
             if parent_id:
-                parent = api.get_one(int(parent_id), ContentType.Folder, workspace)
+                parent = api.get_one(int(parent_id),
+                                     ContentType.Folder,
+                                     workspace)
 
             with DBSession.no_autoflush:
-                folder = api.create(ContentType.Folder, workspace, parent, label)
+                folder = api.create(ContentType.Folder,
+                                    workspace,
+                                    parent,
+                                    label)
 
                 subcontent = dict(
-                    folder = True if can_contain_folders=='on' else False,
-                    thread = True if can_contain_threads=='on' else False,
-                    file = True if can_contain_files=='on' else False,
-                    page = True if can_contain_pages=='on' else False
+                    folder=True if can_contain_folders == 'on' else False,
+                    thread=True if can_contain_threads == 'on' else False,
+                    file=True if can_contain_files == 'on' else False,
+                    page=True if can_contain_pages == 'on' else False
                 )
                 api.set_allowed_content(folder, subcontent)
 
             api.save(folder)
 
             tg.flash(_('Folder created'), CST.STATUS_OK)
-            redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, folder.content_id)
+            redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id,
+                                                    folder.content_id)
         except Exception as e:
-            logger.error(self, 'An unexpected exception has been catched. Look at the traceback below.')
+            error_msg = 'An unexpected exception has been catched. ' \
+                        'Look at the traceback below.'
+            logger.error(self, error_msg)
             traceback.print_exc()
 
             tb = sys.exc_info()[2]
-            tg.flash(_('Folder not created: {}').format(e.with_traceback(tb)), CST.STATUS_ERROR)
+            tg.flash(_('Folder not created: {}').format(e.with_traceback(tb)),
+                     CST.STATUS_ERROR)
             if parent_id:
-                redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, parent_id)
+                redirect_url = \
+                    redirect_url_tmpl.format(tmpl_context.workspace_id,
+                                             parent_id)
             else:
-                redirect_url = '/workspaces/{}'.format(tmpl_context.workspace_id)
+                redirect_url = \
+                    '/workspaces/{}'.format(tmpl_context.workspace_id)
 
         ####
         #
         #
         tg.redirect(tg.url(redirect_url))
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose()
-    def put(self, folder_id, label, can_contain_folders=False, can_contain_threads=False, can_contain_files=False, can_contain_pages=False):
+    def put(self,
+            folder_id,
+            label,
+            can_contain_folders=False,
+            can_contain_threads=False,
+            can_contain_files=False,
+            can_contain_pages=False):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
 
         try:
             folder = api.get_one(int(folder_id), ContentType.Folder, workspace)
             subcontent = dict(
-                folder = True if can_contain_folders=='on' else False,
-                thread = True if can_contain_threads=='on' else False,
-                file = True if can_contain_files=='on' else False,
-                page = True if can_contain_pages=='on' else False
+                folder=True if can_contain_folders == 'on' else False,
+                thread=True if can_contain_threads == 'on' else False,
+                file=True if can_contain_files == 'on' else False,
+                page=True if can_contain_pages == 'on' else False
             )
             with new_revision(folder):
                 if label != folder.label:
-                    # TODO - D.A. - 2015-05-25 - Allow to set folder description
+                    # TODO - D.A. - 2015-05-25
+                    # Allow to set folder description
                     api.update_content(folder, label, folder.description)
                 api.set_allowed_content(folder, subcontent)
 
             next_url = self.url(folder.content_id)
 
         except Exception as e:
-            tg.flash(_('Folder not updated: {}').format(str(e)), CST.STATUS_ERROR)
+            tg.flash(_('Folder not updated: {}').format(str(e)),
+                     CST.STATUS_ERROR)
             next_url = self.url(int(folder_id))
 
         tg.redirect(next_url)
     def _item_type(self):
         return ContentType.Folder
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose()
     def put_archive(self, item_id):
         # TODO - CHECK RIGHTS
         item_id = int(item_id)
         content_api = ContentApi(tmpl_context.current_user)
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
-
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
         try:
-            next_url = self._parent_url.format(item.workspace_id, item.parent_id)
-            undo_url = self._std_url.format(item.workspace_id, item.content_id)+'/put_archive_undo'
-            msg = _('{} archived. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
-
+            next_url = self._parent_url.format(item.workspace_id,
+                                               item.parent_id)
+            tmp_url = self._std_url.format(item.workspace_id,
+                                           item.content_id)
+            undo_url = tmp_url + '/put_archive_undo'
+            archived_msg = '{} archived. ' \
+                           '<a class="alert-link" href="{}">Cancel action</a>'
+            msg = _(archived_msg).format(self._item_type_label,
+                                         undo_url)
             with new_revision(item):
                 content_api.archive(item)
                 content_api.save(item, ActionDescription.ARCHIVING)
-
-            tg.flash(msg, CST.STATUS_OK, no_escape=True) # TODO allow to come back
+            # TODO allow to come back
+            tg.flash(msg, CST.STATUS_OK, no_escape=True)
             tg.redirect(next_url)
         except ValueError as e:
-            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
-            msg = _('{} not archived: {}').format(self._item_type_label, str(e))
+            next_url = self._std_url.format(item.workspace_id,
+                                            item.parent_id,
+                                            item.content_id)
+            msg = _('{} not archived: {}').format(self._item_type_label,
+                                                  str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(next_url)
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose()
     def put_archive_undo(self, item_id):
         # TODO - CHECK RIGHTS
         item_id = int(item_id)
-        content_api = ContentApi(tmpl_context.current_user, True, True) # Here we do not filter deleted items
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+        # Here we do not filter deleted items
+        content_api = ContentApi(tmpl_context.current_user, True, True)
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
         try:
             next_url = self._std_url.format(item.workspace_id, item.content_id)
             msg = _('{} unarchived.').format(self._item_type_label)
                 content_api.save(item, ActionDescription.UNARCHIVING)
 
             tg.flash(msg, CST.STATUS_OK)
-            tg.redirect(next_url )
+            tg.redirect(next_url)
 
         except ValueError as e:
-            msg = _('{} not un-archived: {}').format(self._item_type_label, str(e))
+            msg = _('{} not un-archived: {}').format(self._item_type_label,
+                                                     str(e))
             next_url = self._std_url.format(item.workspace_id, item.content_id)
             # We still use std url because the item has not been archived
             tg.flash(msg, CST.STATUS_ERROR)
         # TODO - CHECK RIGHTS
         item_id = int(item_id)
         content_api = ContentApi(tmpl_context.current_user)
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
         try:
 
-            next_url = self._parent_url.format(item.workspace_id, item.parent_id)
-            undo_url = self._std_url.format(item.workspace_id, item.content_id)+'/put_delete_undo'
-            msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
+            next_url = self._parent_url.format(item.workspace_id,
+                                               item.parent_id)
+            tmp_url = self._std_url.format(item.workspace_id,
+                                           item.content_id)
+            undo_url = tmp_url + '/put_delete_undo'
+            deleted_msg = '{} deleted. ' \
+                          '<a class="alert-link" href="{}">Cancel action</a>'
+            msg = _(deleted_msg).format(self._item_type_label,
+                                        undo_url)
             with new_revision(item):
                 content_api.delete(item)
                 content_api.save(item, ActionDescription.DELETION)
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose()
     def put_delete_undo(self, item_id):
         # TODO - CHECK RIGHTS
 
         item_id = int(item_id)
-        content_api = ContentApi(tmpl_context.current_user, True, True) # Here we do not filter deleted items
-        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+        # Here we do not filter deleted items
+        content_api = ContentApi(tmpl_context.current_user, True, True)
+        item = content_api.get_one(item_id,
+                                   self._item_type,
+                                   tmpl_context.workspace)
         try:
             next_url = self._std_url.format(item.workspace_id, item.content_id)
             msg = _('{} undeleted.').format(self._item_type_label)
 
         except ValueError as e:
             logger.debug(self, 'Exception: {}'.format(e.__str__))
-            back_url = self._parent_url.format(item.workspace_id, item.parent_id)
-            msg = _('{} not un-deleted: {}').format(self._item_type_label, str(e))
+            back_url = self._parent_url.format(item.workspace_id,
+                                               item.parent_id)
+            msg = _('{} not un-deleted: {}').format(self._item_type_label,
+                                                    str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
 
 
 class ContentController(StandardController):
-
-    '''
-    Class of controllers used for example in home to mark read the unread 
+    """
+    Class of controllers used for example in home to mark read the unread
     contents via mark_all_read()
-    '''
+    """
 
     @classmethod
     def current_item_id_key_in_context(cls) -> str:

tracim/tracim/controllers/page.py

+import tg
+from tg import expose
+from tg import tmpl_context
+from preview_generator.manager import PreviewManager
+
+from tracim.config.app_cfg import CFG
+from tracim.controllers import TIMRestController
+from tracim.lib.content import ContentApi
+from tracim.model.data import ContentType
+
+__all__ = ['PagesController']
+
+
+class PagesController(TIMRestController):
+
+    @expose()
+    def _default(self):
+        return '<h2> Error Loading Page</h2>'
+
+    @expose()
+    def get_all(self, *args, **kwargs):
+        file_id = int(tg.request.controller_state.routing_args.get('file_id'))
+        return 'all the pages of document {}'.format(file_id)
+
+    # FIXME https://github.com/tracim/tracim/issues/271
+    @expose(content_type='image/jpeg')
+    def get_one(self,
+                page_id: str='-1',
+                revision_id: str=None,
+                size: int=300,
+                *args, **kwargs):
+        file_id = int(tg.request.controller_state.routing_args.get('file_id'))
+        page = int(page_id)
+        revision_id = int(revision_id) if revision_id != 'latest' else None
+        cache_path = CFG.get_instance().PREVIEW_CACHE
+        preview_manager = PreviewManager(cache_path, create_folder=True)
+        user = tmpl_context.current_user
+        content_api = ContentApi(user,
+                                 show_archived=True,
+                                 show_deleted=True)
+        if revision_id:
+            file_path = content_api.get_one_revision_filepath(revision_id)
+        else:
+            file = content_api.get_one(file_id, self._item_type)
+            file_path = content_api.get_one_revision_filepath(file.revision_id)
+        path = preview_manager.get_jpeg_preview(file_path=file_path,
+                                                page=page,
+                                                height=size,
+                                                width=size)
+        with open(path, 'rb') as large:
+            return large.read()
+
+    @expose(content_type='image/jpeg')
+    def high_quality(self,
+                     page_id: str='-1',
+                     revision_id: int=None,
+                     size: int=1000,
+                     *args, **kwargs):
+        result = self.get_one(page_id=page_id,
+                              revision_id=revision_id,
+                              size=size,
+                              args=args,
+                              kwargs=kwargs)
+        return result
+
+    @expose(content_type='application/pdf')
+    def download_pdf_full(self,
+                          page_id: str,
+                          revision_id: str='-1',
+                          *args, **kwargs):
+        return self.download_pdf_one(page_id='-1',
+                                     revision_id=revision_id,
+                                     args=args, kwargs=kwargs)
+
+    # FIXME https://github.com/tracim/tracim/issues/271
+    @expose(content_type='application/pdf')
+    def download_pdf_one(self,
+                         page_id: str,
+                         revision_id: str=None,
+                         *args, **kwargs):
+        file_id = int(tg.request.controller_state.routing_args.get('file_id'))
+        revision_id = int(revision_id) if revision_id != 'latest' else None
+        page = int(page_id)
+        cache_path = CFG.get_instance().PREVIEW_CACHE
+        preview_manager = PreviewManager(cache_path, create_folder=True)
+        user = tmpl_context.current_user
+        content_api = ContentApi(user,
+                                 show_archived=True,
+                                 show_deleted=True)
+        file = content_api.get_one(file_id, self._item_type)
+        if revision_id:
+            file_path = content_api.get_one_revision_filepath(revision_id)
+        else:
+            file = content_api.get_one(file_id, self._item_type)
+            file_path = content_api.get_one_revision_filepath(file.revision_id)
+        path = preview_manager.get_pdf_preview(file_path=file_path,
+                                               page=page)
+        tg.response.headers['Content-Disposition'] = \
+            'attachment; filename="{}"'.format(file.file_name)
+        with open(path, 'rb') as pdf:
+            return pdf.read()
+
+    @property
+    def _item_type(self):
+        return ContentType.File

tracim/tracim/controllers/previews.py

+from tg import expose
+from tg import tmpl_context
+
+from tracim.controllers import TIMRestController
+from tracim.controllers.page import PagesController
+
+__all__ = ['PreviewsController']
+
+
+# FIXME https://github.com/tracim/tracim/issues/272
+# unused, future removal planned
+class PreviewsController(TIMRestController):
+
+    pages = PagesController()
+
+    @expose()
+    def _default(self, *args, **kwargs) -> str:
+        return '<h2> Error Loading Page</h2>'
+
+    @expose()
+    def get_all(self, *args, **kwargs) -> str:
+        print('getall _ document')
+        return 'all the files'
+
+    @expose()
+    def get_one(self, file_id: int, *args, **kwargs) -> str:
+        print('getone _ document')
+        tmpl_context.file = file_id
+        return 'File n°{}'.format(file_id)

tracim/tracim/controllers/root.py

 # -*- coding: utf-8 -*-
-import tg
 from tg import expose
 from tg import flash
 from tg import lurl
 from tg import require
 from tg import tmpl_context
 from tg import url
-
 from tg.i18n import ugettext as _
-from tracim.controllers.api import APIController
-from tracim.controllers.content import ContentController
-
-from tracim.lib import CST
-from tracim.lib.base import logger
-from tracim.lib.user import CurrentUserGetterApi
-from tracim.lib.content import ContentApi
 
 from tracim.controllers import StandardController
 from tracim.controllers.admin import AdminController
+from tracim.controllers.api import APIController
+from tracim.controllers.calendar import CalendarConfigController
+from tracim.controllers.calendar import CalendarController
+from tracim.controllers.content import ContentController
 from tracim.controllers.debug import DebugController
 from tracim.controllers.error import ErrorController
 from tracim.controllers.help import HelpController
-from tracim.controllers.calendar import CalendarController
-from tracim.controllers.calendar import CalendarConfigController
+from tracim.controllers.previews import PreviewsController
 from tracim.controllers.user import UserRestController
 from tracim.controllers.workspace import UserWorkspaceRestController
+from tracim.lib import CST
+from tracim.lib.base import logger
+from tracim.lib.content import ContentApi
+from tracim.lib.user import CurrentUserGetterApi
 from tracim.lib.utils import replace_reset_password_templates
-
 from tracim.model.data import ContentType
-from tracim.model.serializers import DictLikeClass
-from tracim.model.serializers import CTX
 from tracim.model.serializers import Context
+from tracim.model.serializers import CTX
+from tracim.model.serializers import DictLikeClass
 
 
 class RootController(StandardController):
     debug = DebugController()
     error = ErrorController()
 
-
     # Rest controllers
     workspaces = UserWorkspaceRestController()
     user = UserRestController()
+    previews = PreviewsController()
 
     content = ContentController()
 
         super(RootController, self)._before(args, kw)
         tmpl_context.project_name = "tracim"
 
-
     @expose('tracim.templates.index')
     def index(self, came_from='', *args, **kwargs):
         if request.identity:
         logger.info(self, 'came_from: {}'.format(kwargs))
         return self.index(came_from, args, *kwargs)
 
-
     @expose()
     def post_login(self, came_from=lurl('/home')):
         """
         if not request.identity:
             login_counter = request.environ.get('repoze.who.logins', 0) + 1
             redirect(url('/login'),
-                params=dict(came_from=came_from, __logins=login_counter))
+                     params=dict(came_from=came_from, __logins=login_counter))
 
         user = CurrentUserGetterApi.get_current_user()
 
     @expose()
     def post_logout(self, came_from=lurl('/')):
         """
-        Redirect the user to the initially requested page on logout and say  goodbye as well.
+        Redirect the user to the initially requested page on logout and say
+        goodbye as well.
         """
         flash(_('Successfully logged out. We hope to see you soon!'))
         redirect(came_from)
-        
 
     @require(predicates.not_anonymous())
     @expose('tracim.templates.home')
         fake_api = Context(CTX.CURRENT_USER).toDict({
             'current_user': current_user_content})
 
-
         last_active_contents = ContentApi(user).get_last_active(None, ContentType.Any, None)
         fake_api.last_actives = Context(CTX.CONTENT_LIST).toDict(last_active_contents, 'contents', 'nb')
 
         #
         # return DictLikeClass(result = dictified_user, fake_api=fake_api)
 
-
     @require(predicates.not_anonymous())
     @expose('tracim.templates.search.display')
-    def search(self, keywords = ''):
+    def search(self, keywords=''):
         from tracim.lib.content import ContentApi
 
         user = tmpl_context.current_user
         search_results.keywords = keyword_list
 
         return DictLikeClass(fake_api=fake_api, search=search_results)
-
-

tracim/tracim/lib/content.py

 import tg
 from tg.i18n import ugettext as _
 
+from depot.manager import DepotManager
+
 import sqlalchemy
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm import joinedload
 
         return revision
 
+    # INFO - A.P - 2017-07-03 - python file object getter
+    # in case of we cook a version of preview manager that allows a pythonic
+    # access to files
+    # def get_one_revision_file(self, revision_id: int = None):
+    #     """
+    #     This function allows us to directly get a Python file object from its
+    #     revision identifier.
+    #     :param revision_id: The revision id of the file we want to return
+    #     :return: The corresponding Python file object
+    #     """
+    #     revision = self.get_one_revision(revision_id)
+    #     return DepotManager.get().get(revision.depot_file)
+
+    def get_one_revision_filepath(self, revision_id: int = None) -> str:
+        """
+        This method allows us to directly get a file path from its revision
+        identifier.
+        :param revision_id: The revision id of the filepath we want to return
+        :return: The corresponding filepath
+        """
+        revision = self.get_one_revision(revision_id)
+        depot = DepotManager.get()
+        depot_stored_file = depot.get(revision.depot_file)  # type: StoredFile
+        depot_file_path = depot_stored_file._file_path  # type: str
+        return depot_file_path
+
     def get_one_by_label_and_parent(
             self,
             content_label: str,
         item.file_name = new_filename
         item.file_mimetype = new_mimetype
         item.file_content = new_file_content
+        item.depot_file = new_file_content
         item.revision_type = ActionDescription.REVISION
         return item
 

tracim/tracim/model/data.py

 from sqlalchemy.types import LargeBinary
 from sqlalchemy.types import Text
 from sqlalchemy.types import Unicode
+from depot.fields.sqlalchemy import UploadedFileField
+from depot.fields.upload import UploadedFile
 
 from tracim.lib.utils import lazy_ugettext as l_
 from tracim.lib.exception import ContentRevisionUpdateError
         server_default='',
     )
     file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
+    # TODO - A.P - 2017-07-03 - future removal planned
+    # file_content is to be replaced by depot_file, for now both coexist as
+    # this:
+    # - file_content data is still setted
+    # - newly created revision also gets depot_file data setted
+    # - access to the file of a revision from depot_file exclusively
+    # Here is the tasks workflow of the DB to OnDisk Switch :
+    # - Add depot_file "prototype style"
+    #   https://github.com/tracim/tracim/issues/233 - DONE
+    # - Integrate preview generator feature "prototype style"
+    #   https://github.com/tracim/tracim/issues/232 - DONE
+    # - Write migrations
+    #   https://github.com/tracim/tracim/issues/245
+    #   https://github.com/tracim/tracim/issues/246
+    # - Stabilize preview generator integration
+    #   includes dropping DB file content
+    #   https://github.com/tracim/tracim/issues/249
     file_content = deferred(Column(LargeBinary(), unique=False, nullable=True))
+    # INFO - A.P - 2017-07-03 - Depot Doc
+    # http://depot.readthedocs.io/en/latest/#attaching-files-to-models
+    # http://depot.readthedocs.io/en/latest/api.html#module-depot.fields
+    depot_file = Column(UploadedFileField, unique=False, nullable=True)
     properties = Column('properties', Text(), unique=False, nullable=False, default='')
 
     type = Column(Unicode(32), unique=False, nullable=False)
             setattr(new_rev, column_name, column_value)
 
         new_rev.updated = datetime.utcnow()
+        # TODO APY tweaks here depot_file
+        # import pudb; pu.db
+        # new_rev.depot_file = DepotManager.get().get(revision.depot_file)
+        new_rev.depot_file = revision.file_content
 
         return new_rev
 
     def is_editable(self) -> bool:
         return not self.is_archived and not self.is_deleted
 
+    @property
+    def depot_file(self) -> UploadedFile:
+        return self.revision.depot_file
+
+    @depot_file.setter
+    def depot_file(self, value):
+        self.revision.depot_file = value
+
     def get_current_revision(self) -> ContentRevisionRO:
         if not self.revisions:
             return self.new_revision()
             else:
                 aff = '%d hour%s ago' % (delta.seconds/3600, 's' if delta.seconds/3600>=2 else '')
 
-        return aff
+        return aff

tracim/tracim/model/serializers.py

 # -*- coding: utf-8 -*-
 import cherrypy
-import os
 
 import types
 
-from bs4 import BeautifulSoup
 from babel.dates import format_timedelta
 from babel.dates import format_datetime
 
 import tg
 from tg.i18n import ugettext as _
 from tg.util import LazyString
+
+from depot.manager import DepotManager
+
 from tracim.lib.base import logger
 from tracim.lib.user import CurrentUserGetterApi
 from tracim.model.auth import Profile
             })
         )
 
-        if content.type==ContentType.File:
+        if content.type == ContentType.File:
+            depot = DepotManager.get()
+            depot_stored_file = depot.get(data_container.depot_file)
             result.label = content.label
             result['file'] = DictLikeClass(
-                name = data_container.file_name,
-                size = len(data_container.file_content),
-                mimetype = data_container.file_mimetype)
+                name=data_container.file_name,
+                size=depot_stored_file.content_length,
+                mimetype=data_container.file_mimetype)
         return result
 
     if content.type==ContentType.Folder:

tracim/tracim/templates/file/getone.mak

         <div class="t-half-spacer-above">
             <table class="table table-hover table-condensed table-striped table-bordered">
                 <tr>
+                    <td class="tracim-title">${_('Preview')}</td>
+                    <td>
+                        <table>
+                            <tr>
+                                <td>
+                                    <button type="button" id="prev" onclick="previous_page()">
+                                        <span class="pull-left">
+                                            ${ICON.FA_FW('fa fa-chevron-left')}
+                                        </span>
+                                    </button>
+                                </td>
+                                <td>
+                                    <a id="preview_link"><img id='preview' alt="Preview"></a>
+                                </td>
+                                <td>
+                                    <button type="button" id="next" onclick="next_page()">
+                                        <span>
+                                            ${ICON.FA_FW('fa fa-chevron-right')}
+                                        </span>
+                                    </button>
+                                </td>
+                                <td>
+                                    <a type="button" id="dl_one_pdf">${_('this page')}
+                                        <span class="pull-left">
+                                            ${ICON.FA_FW('fa fa-download')}
+                                        </span>
+                                    </a>
+                                </td>
+                                <td>
+                                    <a type="button" id="dl_full_pdf">${_('all pages')}
+                                        <span class="pull-left">
+                                            ${ICON.FA_FW('fa fa-download')}
+                                        </span>
+                                    </a>
+                                </td>
+                            </tr>
+                        </table>
+
+                        <script type="text/javascript">
+                            var nb_page = parseInt(${nb_page});
+                            console.log(nb_page);
+                            var page = 0;
+                            var urls = [];
+                            % for one_url in url:
+                            urls.push('${one_url}');
+                            % endfor
+                            console.log(urls);
+                            document.getElementById('preview').src = urls[page];
+                            refresh_button();
+
+                            function next_page(){
+                                page = page+1;
+                                console.log('page next');
+                                console.log(urls[page]);
+                                document.getElementById('preview').src = urls[page];
+                                refresh_button();
+                            }
+
+                            function previous_page(){
+                                page = page-1;
+                                console.log('page previous');
+                                console.log(urls[page]);
+                                document.getElementById('preview').src = urls[page];
+                                refresh_button();
+                            }
+
+                            function refresh_button(){
+                                console.log(page);
+                                document.getElementById('prev').disabled = false;
+                                document.getElementById('next').disabled = false;
+                                document.getElementById('dl_one_pdf').href = "/previews/${result.file.id}/pages/" + page + "/download_pdf_one?revision_id=${result.file.selected_revision}";
+                                document.getElementById('dl_full_pdf').href = "/previews/${result.file.id}/pages/" + page + "/download_pdf_full?revision_id=${result.file.selected_revision}";
+                                document.getElementById('preview_link').href = "/previews/${result.file.id}/pages/" + page + "/high_quality?revision_id=${result.file.selected_revision}";
+                                if(page >= nb_page-1){
+                                    document.getElementById('next').disabled = true;
+                                }
+                                if(page <= 0){
+                                    document.getElementById('prev').disabled = true;
+                                }
+                            }
+                        </script>
+                    </td>
+                </tr>
+                <tr>
                     <td class="tracim-title">${_('File')}</td>
                     <td>
                         <a href="${download_url}" tittle="${_('Download the file (last revision)')}">

tracim/tracim/tests/models/test_content.py

 # -*- coding: utf-8 -*-
 import time
-from nose.tools import raises, ok_
+
+from depot.fields.upload import UploadedFile
+from nose.tools import ok_
+from nose.tools import raises
 from sqlalchemy.sql.elements import and_
 from sqlalchemy.testing import eq_
 
 from tracim.lib.content import ContentApi
 from tracim.lib.exception import ContentRevisionUpdateError
-from tracim.model import DBSession, User, Content, new_revision
-from tracim.model.data import ContentRevisionRO, Workspace, ActionDescription, ContentType
+from tracim.model import Content
+from tracim.model import DBSession
+from tracim.model import new_revision
+from tracim.model import User
+from tracim.model.data import ActionDescription
+from tracim.model.data import ContentRevisionRO
+from tracim.model.data import ContentType
+from tracim.model.data import Workspace
 from tracim.tests import TestStandard
 
 
             revision_type=ActionDescription.CREATION,
             is_deleted=False,  # TODO: pk ?
             is_archived=False,  # TODO: pk ?
-            #file_content=None,  # TODO: pk ? (J'ai du mettre nullable=True)
+            # file_content=None,  # TODO: pk ? (J'ai du mettre nullable=True)
         )
 
         eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
 
         return created_content
 
+    def _get_user(self):
+        email = 'admin@admin.admin'
+        user_query = DBSession.query(User)
+        user_filter = user_query.filter(User.email == email)
+        user = user_filter.one()
+        return user
+
     def _create_content(self, *args, **kwargs):
         content = Content(*args, **kwargs)
         DBSession.add(content)
         DBSession.flush()
+        return content
 
+    def _create_content_from_nothing(self):
+        user_admin = self._get_user()
+        workspace = Workspace(label="TEST_WORKSPACE_1")
+        content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.File,
+            label='TEST_CONTENT_1',
+            description='TEST_CONTENT_DESCRIPTION_1',
+            revision_type=ActionDescription.CREATION,
+        )
         return content
+
+    def test_unit__content_depot_file(self):
+        """ Depot file access thought content property methods. """
+        content = self._create_content_from_nothing()
+        # tests uninitialized depot file
+        eq_(content.depot_file, None)
+        # initializes depot file
+        # which is able to behave like a python file object
+        content.depot_file = b'test'
+        # tests initialized depot file
+        ok_(content.depot_file)
+        # tests type of initialized depot file
+        eq_(type(content.depot_file), UploadedFile)
+        # tests content of initialized depot file
+        # using depot_file.file of type StoredFile to fetch content back
+        eq_(content.depot_file.file.read(), b'test')