merge with master

README.md

 
 In case you prefer using Docker:
 
-    sudo docker run -e DATABASE_TYPE=sqlite \
-               -p 80:80 -p 3030:3030 -p 5232:5232 \
-               -v /var/tracim/etc:/etc/tracim -v /var/tracim/var:/var/tracim algoo/tracim
+You need to install docker on your server first (see [here for debian](https://docs.docker.com/install/linux/docker-ce/debian/) or [here for windows]([docker toolbox](https://docs.docker.com/toolbox/toolbox_install_windows/)))
+
+Make sure `docker.service` is started correctly.
+
+    systemctl status docker.service
+
+Then use image like following (adapt volume paths or ports as you want):
+
+    sudo docker run \
+        -e DATABASE_TYPE=sqlite \
+        -p 80:80 \
+        -p 3030:3030 \
+        -p 5232:5232 \
+        -v /var/tracim/etc:/etc/tracim \
+        -v /var/tracim/var:/var/tracim \
+        algoo/tracim  # docker image: tracim:unstable for development version, tracim_test:latest for nightly builds
+
+
+All docker images are available here : https://hub.docker.com/u/algoo/
+More information about build docker image: https://github.com/tracim/docker_tracim
+
+Description of versioning:
+
+* algoo/`tracim:latest` is latest stable image from branch master
+* algoo/`tracim:<$tag>` is a stable tag image from branch master
+* algoo/`tracim_testing:latest` is a latest image from branch develop
+* algoo/`tracim:unstable` is a latest unstable image from branch develop
+
+----
 
 ## Install Tracim on your server ##
 

doc/apache.md

 
 ### Installation ###
 
-Install `Apache` server and its [`WSGI` module](https://github.com/GrahamDumpleton/mod_wsgi):
+Install `tracim` first.
+Install `Apache` server and uwsgi  its [`WSGI` module](https://github.com/GrahamDumpleton/mod_wsgi):
 
-    sudo apt install apache2 libapache2-mod-wsgi-py3
+    sudo apt install apache2 libapache2-mod-wsgi-py3 uwsgi uwsgi-plugin-python3
 
 ### Configuration ###
 
 Create a file named `/etc/apache2/sites-available/tracim.conf` containing:
 
-    Listen 8080
+    Listen 80
 
-    <VirtualHost *:8080>
+    <VirtualHost *:80>
         ServerName tracim
 
-        # Serve Tracim through WSGI
-        WSGIDaemonProcess tracim user=[your_user] group=[your_user] threads=4 python-home=[tracim_path]/tg2env python-path=[tracim_path]/tracim lang='C.UTF-8' locale='C.UTF-8'
-        WSGIProcessGroup tracim
-        WSGIScriptAlias / [tracim_path]/tracim/app.wsgi process-group=tracim
-        <Directory "[tracim_path]/tracim">
-            <Files "app.wsgi">
-                Require all granted
-            </Files>
-        </Directory>
-
-        # Serve static files directly
-        Alias /assets          [tracim_path]/tracim/tracim/public/assets
-        Alias /_caldavzap      [tracim_path]/tracim/tracim/public/_caldavzap
-        Alias /favicon.ico     [tracim_path]/tracim/tracim/public/favicon.ico
-        <Directory "[tracim_path]/tracim/tracim/public">
-            Require all granted
-        </Directory>
+    <Directory "/">
+        Require all granted
+        Dav On
+    </Directory>
+    ProxyPreserveHost On 
+    CustomLog /var/log/apache2/algoo-access.log combined
+    ErrorLog /var/log/apache2/algoo-error.log
+    <Location "/webdav">
+        # Dav On
+    </Location>
+
+    # RemoteIPHeader X-Forwarded-For
+    ProxyPass /webdav http://127.0.0.1:3030/webdav
+    ProxyPassReverse /webdav http://127.0.0.1:3030/webdav
+    ProxyPass / http://127.0.0.1:8080/
+    ProxyPassReverse / http://127.0.0.1:8080/
+
     </VirtualHost>
 
-Replace `[tracim_path]` and `[your_user]` above by your tracim installation path and your user.
+Enable this configuration file:
+
+    sudo ln -s /etc/apache2/sites-available/tracim.conf /etc/apache2/sites-enabled/
+
+Check if you just have `tracim.conf` in `/etc/apache2/sites-enabled`, if not, remove other file.
+
+
+Create the file named `/etc/uwsgi/apps-available/tracim.ini` containing:
+
+    [uwsgi]
+    plugins = python3
+    chdir = [tracim_path]/tracim
+    home = [tracim_path]/tg2env
+    wsgi-file = app.wsgi
+    callable = application
+    http-socket = 0.0.0.0:8080
+    enable-threads = true
+    env = PYTHON_EGG_CACHE=/tmp
+
+Replace [tracim_path] by your path of tracim
 
-Set the `APP_CONFIG` variable of the `tracim/app.wsgi` file to match your tracim installation path:
+Enable this configuration file:
+
+    sudo ln -s /etc/uwsgi/apps-available/tracim.ini /etc/uwsgi/apps-enabled/
+
+
+Create file `tracim.log` in `/var/log/uwsgi/app/`
+
+Set the `APP_CONFIG` variable of the `[tracim_path]/tracim/app.wsgi` file to match your tracim installation path:
 
     # -*- coding: utf-8 -*-
 
-    APP_CONFIG = "[tracim_path]/tracim/development.ini"
+    APP_CONFIG = "[tracim_path]/tracim/development.ini" 
+    #(in file: replace /var/www/tracim by your [tracim_path] )
 
     #Setup logging
     # import logging
     application = loadapp('config:%s' % APP_CONFIG)
     application.debug = False
 
+
+Add `webdav` at `root_path` in the `[tracim_path]/tracim/wsgidav.conf`:
+
+    ################################################################################
+    # Sample WsgiDAV configuration file
+    #
+    # 1. Rename this file to `wsgidav.conf`
+    # 2. Adjust settings as appropriate
+    # 3. Run tracim as you always do :)
+    #
+    ################################################################################
+    
+    ################################################################################
+    # SERVER OPTIONS
+    #===============================================================================
+    
+    # host  = "localhost"
+    # host  = "192.168.0.1"
+    host  = "0.0.0.0"
+    
+    port = 3030
+    
+    show_history = True
+    show_deleted = True
+    show_archived = True
+    
+    manager_locks = True
+    
+    root_path = ''
+    
+    # Tracim doesn't support digest auth for webdav
+    acceptbasic = True
+    acceptdigest = False
+    defaultdigest = False
+    #===============================================================================
+    # Lock Manager
+    #
+    # Example: Use PERSISTENT shelve based lock manager
+    #from wsgidav.lock_storage import LockStorageShelve
+    #locksmanager = LockStorageShelve("wsgidav-locks.shelve")
+
+
+
+Open `[tracim_path]/tracim/development.ini` and make some change:
+
+
+    In [server:main] modify IP:
+    `host = 127.0.0.1` by `host = 0.0.0.0`
+
+    For Radical (CalDav server):
+    Uncomment `# radicale.server.host = 0.0.0.0`
+    Uncomment `# radicale.server.allow_origin = *`
+    Uncomment `# radicale.client.base_url.host = http://127.0.0.1:5232`
+    and modifiy IP `# radicale.client.base_url.host = http://127.0.0.1:5232`to `radicale.client.base_url.host = http://[Your_server_IP]:5232`
+    
+    For WSGIDAV
+    Uncomment `# wsgidav.client.base_url = 127.0.0.1:<WSGIDAV_PORT>`
+    and modify IP and PORT `# wsgidav.client.base_url = 127.0.0.1:<WSGIDAV_PORT>` to `wsgidav.client.base_url = [Your_server_IP]/webdav`
+
+
+Restart `uwsgi` configuration:
+
+    sudo systemctl restart uwsgi.service
+
 Load needed proxy modules and enable this site configuration file:
 
-    sudo a2enmod proxy proxy_http
+    sudo a2enmod dav_fs dav proxy proxy_http
     sudo a2ensite tracim.conf
 
-Reload `Apache` configuration:
+Restart `Apache` configuration:
 
-    sudo systemctl reload apache2.service
+    sudo systemctl restart apache2.service
+    
+**Important**
+In case you have some permission problem, check if `www-data` can access to folder of tracim.
 
 ## Documentation Links ##
 
-[TurboGears](http://turbogears.readthedocs.io/en/tg2.3.7/cookbook/deploy/mod_wsgi.html)
-
-[mod_wsgi](http://modwsgi.readthedocs.io/en/develop/index.html)
+* [Apache](https://httpd.apache.org/docs/2.4/fr/)
+* [TurboGears](http://turbogears.readthedocs.io/en/tg2.3.7/cookbook/deploy/mod_wsgi.html)
+* [mod_wsgi](http://modwsgi.readthedocs.io/en/develop/index.html)

doc/devtools.md

+# Devtools
+
+# Check third party licences
+
+Install `yolk3k` pip package:
+
+    pip install yolk3k
+
+Then execute command:
+
+    yolk -l -f license
+
+Output will look like:
+
+```
+Babel (2.2.0)
+    License: BSD
+
+Beaker (1.6.4)
+    License: BSD
+
+CherryPy (3.6.0)
+    License: BSD
+
+FormEncode (1.3.0a1)
+    License: PSF
+
+Genshi (0.7)
+    License: BSD
+...
+```

doc/webdav.md

+# How to use webdav from different OS ?
+
+## Windows
+
+### Windows 7
+
+- Open Start Menu.
+- Click on Computer.
+- click on "Map network drive".
+
+### Windows 8 and 10
+
+- Open File explorer.
+- Right click on "This PC" (left panel)
+- From the dropdown menu, select "Map network drive".
+
+### Map Network drive Windows:
+
+Webdav Windows addresses are similar to:
+
+```
+https://<yourinstance>/webdav/ (secure)
+http://<yourinstance>/webdav/ (unsecure)
+```
+
+- Enter the address of webdav (you can find it in each workspace, under workspace details)
+- Check "Reconnect at sign-in" and "Connect using different credentials".
+- Click "Finish".
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.
+
+### Unsecure HTTP using Windows
+
+If you want to use webdav with tracim without https, you need to set Windows to accept basic auth in http.
+
+To enable it:
+- Launch regedit.
+- Go to "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters\BasicAuthLevel".
+- set "BasicAuthLevel" to "2".
+
+## OSX
+
+Webdav OSX addresses are similar to:
+
+```
+https://<yourinstance>/webdav/ (secure)
+http://<yourinstance>/webdav/ (unsecure)
+```
+
+- In the Finder, choose "Go > Connect to Server".
+- Enter the address of webdav (you can find it in each workspace, under workspace details). Click Connect.
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.
+
+## Linux
+
+Webdav Linux addresses are similar to:
+
+```
+davs://<yourinstance>/webdav/ (secure)
+dav://<yourinstance>/webdav/ (unsecure)
+```
+
+### Gnome3 (nautilus)
+
+- Launch nautilus.
+- Show url bar : Ctrl+l.
+- Enter the address of webdav (you can find it in each workspace, under workspace details). Press Enter.
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.

tracim/migration/versions/2b4043fa2502_remove_webdav_right_digest_response_.py

+"""remove webdav_right_digest_response_hash from database
+
+Revision ID: 2b4043fa2502
+Revises: f3852e1349c4
+Create Date: 2018-03-13 14:41:38.590375
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '2b4043fa2502'
+down_revision = 'f3852e1349c4'
+
+from alembic import op
+from sqlalchemy import Column, Unicode
+
+
+def upgrade():
+    with op.batch_alter_table('users') as batch_op:
+        batch_op.drop_column('webdav_left_digest_response_hash')
+
+
+def downgrade():
+    with op.batch_alter_table('users') as batch_op:
+        batch_op.add_column(
+            Column('webdav_left_digest_response_hash', Unicode(128))
+        )

tracim/tracim/controllers/workspace.py

 
 from tracim.model.serializers import Context, CTX, DictLikeClass
 
+from urllib.parse import urlparse
 
 class UserWorkspaceRestController(TIMRestController):
 
         videoconf_enabled = CFG.get_instance().JITSI_MEET_ACTIVATED
 
         dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace, 'workspace')
+
         webdav_url = CFG.get_instance().WSGIDAV_CLIENT_BASE_URL
+        website_protocol = urlparse(CFG.get_instance().WEBSITE_BASE_URL).scheme
+        dav_protocol = 'dav'
+        if website_protocol == "https":
+            dav_protocol = 'davs'
 
         return DictLikeClass(
             result=dictified_workspace,
             fake_api=fake_api,
             webdav_url=webdav_url,
             videoconf_enabled=videoconf_enabled,
+            website_protocol = website_protocol,
+            dav_protocol = dav_protocol,
             show_deleted=show_deleted,
             show_archived=show_archived,
         )

tracim/tracim/i18n/fr/LC_MESSAGES/tracim.po

 
 #: tracim/templates/admin/workspace_getall.mak:48
 msgid "<u>Note</u>: members will be added during next step."
-msgstr "<u>Note</u> : les membres seront ajoutées à la prochaine étape."
+msgstr "<u>Note</u> : les membres seront ajouté(e)s à la prochaine étape."
 
 #: tracim/templates/admin/workspace_getall.mak:75
 msgid "User Nb"
 "This workspace offers a calendar that you can configure in your software:"
 " Outlook, Thunderbird, etc."
 msgstr ""
-"Cet espace de travaille propose un calendrier que vous pouvez configurer "
+"Cet espace de travail propose un calendrier que vous pouvez configurer "
 "dans votre logiciel : Outlook, Thunderbird, etc."
 
 #: tracim/templates/admin/workspace_getone.mak:46

tracim/tracim/lib/content.py

 from tracim.lib import cmp_to_key
 from tracim.lib.notifications import NotifierFactory
 from tracim.lib.utils import SameValueError
+from tracim.lib.utils import current_date_for_filename
 from tracim.model import DBSession
 from tracim.model import new_revision
 from tracim.model.auth import User
 
         item.revision_type = ActionDescription.MOVE
 
+    def copy(
+        self,
+        item: Content,
+        new_parent: Content=None,
+        new_label: str=None,
+        do_save: bool=True,
+        do_notify: bool=True,
+    ) -> Content:
+        """
+        Copy nearly all content, revision included. Children not included, see
+        "copy_children" for this.
+        :param item: Item to copy
+        :param new_parent: new parent of the new copied item
+        :param new_label: new label of the new copied item
+        :param do_notify: notify copy or not
+        :return: Newly copied item
+        """
+        if (not new_parent and not new_label) or (new_parent == item.parent and new_label == item.label):  # nopep8
+            # TODO - G.M - 08-03-2018 - Use something else than value error
+            raise ValueError("You can't copy file into itself")
+        if new_parent:
+            workspace = new_parent.workspace
+            parent = new_parent
+        else:
+            workspace = item.workspace
+            parent = item.parent
+        label = new_label or item.label
+
+        content = item.copy(parent)
+        # INFO - GM - 15-03-2018 - add "copy" revision
+        with new_revision(content, force_create_new_revision=True) as rev:
+            rev.parent = parent
+            rev.workspace = workspace
+            rev.label = label
+            rev.revision_type = ActionDescription.COPY
+            rev.properties['origin'] = {
+                'content': item.id,
+                'revision': item.last_revision.revision_id,
+            }
+        if do_save:
+            self.save(content, ActionDescription.COPY, do_notify=do_notify)
+        return content
+
+    def copy_children(self, origin_content: Content, new_content: Content):
+        for child in origin_content.children:
+            self.copy(child, new_content)
+
     def move_recursively(self, item: Content,
                          new_parent: Content, new_workspace: Workspace):
         self.move(item, new_parent, False, new_workspace)
     def archive(self, content: Content):
         content.owner = self._user
         content.is_archived = True
+        # TODO - G.M - 12-03-2018 - Inspect possible label conflict problem
+        # INFO - G.M - 12-03-2018 - Set label name to avoid trouble when
+        # un-archiving file.
+        content.label = '{label}-{action}-{date}'.format(
+            label=content.label,
+            action='archived',
+            date=current_date_for_filename()
+        )
         content.revision_type = ActionDescription.ARCHIVING
 
     def unarchive(self, content: Content):
     def delete(self, content: Content):
         content.owner = self._user
         content.is_deleted = True
+        # TODO - G.M - 12-03-2018 - Inspect possible label conflict problem
+        # INFO - G.M - 12-03-2018 - Set label name to avoid trouble when
+        # un-deleting file.
+        content.label = '{label}-{action}-{date}'.format(
+            label=content.label,
+            action='deleted',
+            date=current_date_for_filename()
+        )
         content.revision_type = ActionDescription.DELETION
 
     def undelete(self, content: Content):

tracim/tracim/lib/daemons.py

 from tracim.lib.exceptions import AlreadyRunningDaemon
 
 from tracim.lib.utils import get_rq_queue
+from tracim.lib.utils import TracimEnforceHTTPS
 from tracim.lib.email_fetcher import MailFetcher
 
 
             print(
                 "WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/.")
         from wsgidav.dir_browser import WsgiDavDirBrowser
-        from tracim.lib.webdav.tracim_http_authenticator import TracimHTTPAuthenticator
+        from wsgidav.http_authenticator import HTTPAuthenticator
         from wsgidav.error_printer import ErrorPrinter
         from tracim.lib.webdav.utils import TracimWsgiDavDebugFilter
 
         config['middleware_stack'] = [
+            TracimEnforceHTTPS,
             WsgiDavDirBrowser,
-            TracimHTTPAuthenticator,
+            HTTPAuthenticator,
             ErrorPrinter,
             TracimWsgiDavDebugFilter,
         ]

tracim/tracim/lib/utils.py

 # -*- coding: utf-8 -*-
+import datetime
 import os
 import time
 import signal
 from rq import Queue
 from unidecode import unidecode
 
+from wsgidav.middleware import BaseMiddleware
 from tracim.lib.base import logger
 from webob import Response
 from webob.exc import WSGIHTTPException
         port=cfg.EMAIL_SENDER_REDIS_PORT,
         db=cfg.EMAIL_SENDER_REDIS_DB,
     ))
+
+def current_date_for_filename() -> str:
+    """
+    ISO8601 current date, adapted to be used in filename (for
+    webdav feature for example), with trouble-free characters.
+    :return: current date as string like "2018-03-19T15.49.27.246592"
+    """
+    # INFO - G.M - 19-03-2018 - As ':' is in transform_to_bdd method in
+    # webdav utils, it may cause trouble. So, it should be replaced to
+    # a character which will not change in bdd.
+    return datetime.datetime.now().isoformat().replace(':', '.')
+
+class TracimEnforceHTTPS(BaseMiddleware):
+
+    def __init__(self, application, config):
+        super().__init__(application, config)
+        self._application = application
+        self._config = config
+
+    def __call__(self, environ, start_response):
+        # TODO - G.M - 06-03-2018 - Check protocol from http header first
+        # see http://www.bortzmeyer.org/7239.html
+        # if this params doesn't exist, rely on tracim config
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+
+        if cfg.WEBSITE_BASE_URL.startswith('https'):
+            environ['wsgi.url_scheme'] = 'https'
+        return self._application(environ, start_response)

tracim/tracim/lib/webdav/design.py

     'unarchiving': 'Item unarchived',
     'undeletion': 'Item undeleted',
     'move': 'Item moved',
-    'comment': 'Comment'
+    'comment': 'Comment',
+    'copy' : 'Item copied',
 }
 
 
     return aff
 
 def designPage(content: data.Content, content_revision: data.ContentRevisionRO) -> str:
-    hist = content.get_history()
+    hist = content.get_history(drop_empty_revision=False)
     histHTML = '<table class="table table-striped table-hover">'
     for event in hist:
         if isinstance(event, VirtualEvent):
     return page
 
 def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
-        hist = content.get_history()
+        hist = content.get_history(drop_empty_revision=False)
 
         allT = []
         allT += comments

tracim/tracim/lib/webdav/sql_domain_controller.py

 
 from tracim.lib.user import UserApi
 
+class DigestAuthNotImplemented(Exception):
+    pass
+
 class TracimDomainController(object):
     """
     The domain controller is used by http_authenticator to authenticate the user every time a request is
     def getDomainRealm(self, inputURL, environ):
         return '/'
 
+    def getRealmUserPassword(self, realmname, username, environ):
+        """
+        This method is normally only use for digest auth. wsgidav need
+        plain password to deal with it. as we didn't
+        provide support for this kind of auth, this method raise an exception.
+        """
+        raise DigestAuthNotImplemented
+
     def requireAuthentication(self, realmname, environ):
         return True
 
         except:
             return False
 
-    def get_left_digest_response_hash(self, realmname, username, environ):
-        """
-        Called by our http_authenticator to get the hashed md5 digest for the current user that is also sent by
-        the webdav client
-        """
-        try:
-            user = self._api.get_one_by_email(username)
-            return user.webdav_left_digest_response_hash
-        except:
-            return None
-
     def authDomainUser(self, realmname, username, password, environ):
         """
         If you ever feel the need to send a request al-mano with a curl, this is the function that'll be called by

tracim/tracim/lib/webdav/sql_resources.py

 
 class ManageActions(object):
     """
-    This object is used to encapsulate all Deletion/Archiving related method as to not duplicate too much code
+    This object is used to encapsulate all Deletion/Archiving related
+    method as to not duplicate too much code
     """
     def __init__(self, action_type: str, api: ContentApi, content: Content):
         self.content_api = api
             ActionDescription.UNDELETION: self.content_api.undelete
         }
 
-        self._to_name = {
-            ActionDescription.ARCHIVING: 'archived',
-            ActionDescription.DELETION: 'deleted'
-        }
-
         self._type = action_type
-        self._new_name = self.make_name()
 
     def action(self):
-        try:
-            # When undeleting/unarchiving we except a content with the new name to not exist, thus if we
-            # don't get an error and the database request send back a result, we stop the action
-            self.content_api.get_one_by_label_and_parent(self._new_name, self.content.parent)
-            raise DAVError(HTTP_FORBIDDEN)
-        except NoResultFound:
-            with new_revision(self.content):
-                self.content_api.update_content(self.content, self._new_name)
-                self._actions[self._type](self.content)
-                self.content_api.save(self.content, self._type)
-
-            transaction.commit()
-
-    def make_name(self) -> str:
-        """
-        Will create the new name, either by adding '- deleted the [date]' after the name when archiving/deleting or
-        removing this string when undeleting/unarchiving
-        """
-        new_name = self.content.get_label_as_file()
-        extension = ''
-
-        # if the content has no label, the last .ext is important
-        # thus we want to rename a file from 'file.txt' to 'file - deleted... .txt' and not 'file.txt - deleted...'
-        is_file_name = self.content.label == ''
-        if is_file_name:
-            search = re.search(r'(\.[^.]+)$', new_name)
-            if search:
-                extension = search.group(0)
-            new_name = re.sub(r'(\.[^.]+)$', '', new_name)
-
-        if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]:
-            new_name += ' - %s the %s' % (self._to_name[self._type], datetime.now().strftime('%d-%m-%Y at %H:%M'))
-        else:
-            new_name = re.sub(
-                r'( - (%s|%s) the .*)$' % (self._to_name[ActionDescription.DELETION], self._to_name[ActionDescription.ARCHIVING]),
-                '',
-                new_name
-            )
-
-        new_name += extension
+        with new_revision(self.content):
+            self._actions[self._type](self.content)
+            self.content_api.save(self.content, self._type)
 
-        return new_name
+        transaction.commit()
 
 
 class Root(DAVCollection):
         if invalid_path:
             raise DAVError(HTTP_FORBIDDEN)
 
-    def move_file(self, destpath):
+    def move_file(self, destpath: str) -> None:
+        """
+        Move file mean changing the path to access to a file. This can mean
+        simple renaming(1), moving file from a directory to one another(2)
+        but also renaming + moving file from a directory to one another at
+        the same time (3).
+
+        (1): move /dir1/file1 -> /dir1/file2
+        (2): move /dir1/file1 -> /dir2/file1
+        (3): move /dir1/file1 -> /dir2/file2
+        :param destpath: destination path of webdav move
+        :return: nothing
+        """
 
         workspace = self.content.workspace
         parent = self.content.parent
 
         with new_revision(self.content):
+            # INFO - G.M - 2018-03-09 - First, renaming file if needed
             if basename(destpath) != self.getDisplayName():
                 new_given_file_name = transform_to_bdd(basename(destpath))
                 new_file_name, new_file_extension = \
                 )
                 self.content.file_extension = new_file_extension
                 self.content_api.save(self.content)
-            else:
-                workspace_api = WorkspaceApi(self.user)
-                content_api = ContentApi(self.user)
 
-                destination_workspace = self.provider.get_workspace_from_path(
-                    destpath,
-                    workspace_api,
-                )
-
-                destination_parent = self.provider.get_parent_from_path(
-                    destpath,
-                    content_api,
-                    destination_workspace,
-                )
+            # INFO - G.M - 2018-03-09 - Moving file if needed
+            workspace_api = WorkspaceApi(self.user)
+            content_api = ContentApi(self.user)
 
+            destination_workspace = self.provider.get_workspace_from_path(
+                destpath,
+                workspace_api,
+            )
+            destination_parent = self.provider.get_parent_from_path(
+                destpath,
+                content_api,
+                destination_workspace,
+            )
+            if destination_parent != parent or destination_workspace != workspace:  # nopep8
+                #  INFO - G.M - 12-03-2018 - Avoid moving the file "at the same place"  # nopep8
+                #  if the request does not result in a real move.
                 self.content_api.move(
                     item=self.content,
                     new_parent=destination_parent,
 
         transaction.commit()
 
+    def copyMoveSingle(self, destpath, isMove):
+        if isMove:
+            # INFO - G.M - 12-03-2018 - This case should not happen
+            # As far as moveRecursive method exist, all move should not go
+            # through this method. If such case appear, try replace this to :
+            ####
+            # self.move_file(destpath)
+            # return
+            ####
+
+            raise NotImplemented
+
+        new_file_name = None
+        new_file_extension = None
+
+        # Inspect destpath
+        if basename(destpath) != self.getDisplayName():
+            new_given_file_name = transform_to_bdd(basename(destpath))
+            new_file_name, new_file_extension = \
+                os.path.splitext(new_given_file_name)
+
+        workspace_api = WorkspaceApi(self.user)
+        content_api = ContentApi(self.user)
+        destination_workspace = self.provider.get_workspace_from_path(
+            destpath,
+            workspace_api,
+        )
+        destination_parent = self.provider.get_parent_from_path(
+            destpath,
+            content_api,
+            destination_workspace,
+        )
+        workspace = self.content.workspace
+        parent = self.content.parent
+        new_content = self.content_api.copy(
+            item=self.content,
+            new_label=new_file_name,
+            new_parent=destination_parent,
+        )
+        self.content_api.copy_children(self.content, new_content)
+        transaction.commit()
+
     def supportRecursiveMove(self, destPath):
         return True
 

tracim/tracim/lib/webdav/tracim_http_authenticator.py

-import os
-import re
-
-from wsgidav.http_authenticator import HTTPAuthenticator
-from wsgidav import util
-import cherrypy
-
-from tracim.lib.user import CurrentUserGetterApi
-from tracim.lib.user import CURRENT_USER_WSGIDAV
-
-_logger = util.getModuleLogger(__name__, True)
-HOTFIX_WINXP_AcceptRootShareLogin = True
-
-
-class TracimHTTPAuthenticator(HTTPAuthenticator):
-    def __init__(self, application, config):
-        super(TracimHTTPAuthenticator, self).__init__(application, config)
-        self._headerfixparser = re.compile(r'([\w]+)=("[^"]*,[^"]*"),')
-
-    def authDigestAuthRequest(self, environ, start_response):
-        realmname = self._domaincontroller.getDomainRealm(environ["PATH_INFO"], environ)
-
-        isinvalidreq = False
-
-        authheaderdict = dict([])
-        authheaders = environ["HTTP_AUTHORIZATION"] + ","
-        if not authheaders.lower().strip().startswith("digest"):
-            isinvalidreq = True
-            # Hotfix for Windows file manager and OSX Finder:
-        # Some clients don't urlencode paths in auth header, so uri value may
-        # contain commas, which break the usual regex headerparser. Example:
-        # Digest username="user",realm="/",uri="a,b.txt",nc=00000001, ...
-        # -> [..., ('uri', '"a'), ('nc', '00000001'), ...]
-        # Override any such values with carefully extracted ones.
-        authheaderlist = self._headerparser.findall(authheaders)
-        authheaderfixlist = self._headerfixparser.findall(authheaders)
-        if authheaderfixlist:
-            _logger.info("Fixing authheader comma-parsing: extend %s with %s" \
-                         % (authheaderlist, authheaderfixlist))
-            authheaderlist += authheaderfixlist
-        for authheader in authheaderlist:
-            authheaderkey = authheader[0]
-            authheadervalue = authheader[1].strip().strip("\"")
-            authheaderdict[authheaderkey] = authheadervalue
-
-        _logger.debug("authDigestAuthRequest: %s" % environ["HTTP_AUTHORIZATION"])
-        _logger.debug("  -> %s" % authheaderdict)
-
-        if "username" in authheaderdict:
-            req_username = authheaderdict["username"]
-            req_username_org = req_username
-            # Hotfix for Windows XP:
-            #   net use W: http://127.0.0.1/dav /USER:DOMAIN\tester tester
-            # will send the name with double backslashes ('DOMAIN\\tester')
-            # but send the digest for the simple name ('DOMAIN\tester').
-            if r"\\" in req_username:
-                req_username = req_username.replace("\\\\", "\\")
-                _logger.info("Fixing Windows name with double backslash: '%s' --> '%s'" % (req_username_org, req_username))
-
-            if not self._domaincontroller.isRealmUser(realmname, req_username, environ):
-                isinvalidreq = True
-        else:
-            isinvalidreq = True
-
-            # TODO: Chun added this comments, but code was commented out
-            # Do not do realm checking - a hotfix for WinXP using some other realm's
-            # auth details for this realm - if user/password match
-
-        if 'realm' in authheaderdict:
-            if authheaderdict["realm"].upper() != realmname.upper():
-                if HOTFIX_WINXP_AcceptRootShareLogin:
-                    # Hotfix: also accept '/'
-                    if authheaderdict["realm"].upper() != "/":
-                        isinvalidreq = True
-                else:
-                    isinvalidreq = True
-
-        if "algorithm" in authheaderdict:
-            if authheaderdict["algorithm"].upper() != "MD5":
-                isinvalidreq = True  # only MD5 supported
-
-        if "uri" in authheaderdict:
-            req_uri = authheaderdict["uri"]
-
-        if "nonce" in authheaderdict:
-            req_nonce = authheaderdict["nonce"]
-        else:
-            isinvalidreq = True
-
-        req_hasqop = False
-        if "qop" in authheaderdict:
-            req_hasqop = True
-            req_qop = authheaderdict["qop"]
-            if req_qop.lower() != "auth":
-                isinvalidreq = True  # only auth supported, auth-int not supported
-        else:
-            req_qop = None
-
-        if "cnonce" in authheaderdict:
-            req_cnonce = authheaderdict["cnonce"]
-        else:
-            req_cnonce = None
-            if req_hasqop:
-                isinvalidreq = True
-
-        if "nc" in authheaderdict:  # is read but nonce-count checking not implemented
-            req_nc = authheaderdict["nc"]
-        else:
-            req_nc = None
-            if req_hasqop:
-                isinvalidreq = True
-
-        if "response" in authheaderdict:
-            req_response = authheaderdict["response"]
-        else:
-            isinvalidreq = True
-
-        if not isinvalidreq:
-            left_digest_response_hash = self._domaincontroller.get_left_digest_response_hash(realmname, req_username, environ)
-
-            req_method = environ["REQUEST_METHOD"]
-
-            required_digest = self.tracim_compute_digest_response(left_digest_response_hash, req_method, req_uri, req_nonce,
-                                                         req_cnonce, req_qop, req_nc)
-
-            if required_digest != req_response:
-                _logger.warning("computeDigestResponse('%s', '%s', ...): %s != %s" % (
-                realmname, req_username, required_digest, req_response))
-                isinvalidreq = True
-            else:
-                _logger.debug("digest succeeded for realm '%s', user '%s'" % (realmname, req_username))
-            pass
-
-        if isinvalidreq:
-            _logger.warning("Authentication failed for user '%s', realm '%s'" % (req_username, realmname))
-            return self.sendDigestAuthResponse(environ, start_response)
-
-        environ["http_authenticator.realm"] = realmname
-        environ["http_authenticator.username"] = req_username
-
-        # Set request current user email to be able to recognise him later
-        cherrypy.request.current_user_email = req_username
-        CurrentUserGetterApi.set_thread_local_getter(CURRENT_USER_WSGIDAV)
-
-        return self._application(environ, start_response)
-
-    def tracim_compute_digest_response(self, left_digest_response_hash, method, uri, nonce, cnonce, qop, nc):
-        # A1 : username:realm:password
-        A2 = method + ":" + uri
-        if qop:
-            digestresp = self.md5kd(left_digest_response_hash, nonce + ":" + nc + ":" + cnonce + ":" + qop + ":" + self.md5h(A2))
-        else:
-            digestresp = self.md5kd(left_digest_response_hash, nonce + ":" + self.md5h(A2))
-            # print(A1, A2)
-        # print(digestresp)
-        return digestresp

tracim/tracim/model/__init__.py

 
 
 @contextmanager
-def new_revision(content: Content) -> Content:
+def new_revision(
+        content: Content,
+        force_create_new_revision: bool=False,
+) -> Content:
     """
     Prepare context to update a Content. It will add a new updatable revision to the content.
     :param content: Content instance to update
     """
     with DBSession.no_autoflush:
         try:
-            if inspect(content.revision).has_identity:
+            if force_create_new_revision \
+                    or inspect(content.revision).has_identity:
                 content.new_revision()
             RevisionsIntegrity.add_to_updatable(content.revision)
             yield content

tracim/tracim/model/auth.py

     is_active = Column(Boolean, default=True, nullable=False)
     imported_from = Column(Unicode(32), nullable=True)
     timezone = Column(Unicode(255), nullable=False, server_default='')
-    _webdav_left_digest_response_hash = Column('webdav_left_digest_response_hash', Unicode(128))
     auth_token = Column(Unicode(255))
     auth_token_created = Column(DateTime)
 
 
         Hash cleartext password on the fly,
         Store its ciphertext version,
-        Update the WebDAV hash as well.
         """
         self._password = self._hash_password(cleartext_password)
-        self.update_webdav_digest_auth(cleartext_password)
 
     def _get_password(self) -> str:
         """Return the hashed version of the password."""
     password = synonym('_password', descriptor=property(_get_password,
                                                         _set_password))
 
-    @classmethod
-    def _hash_digest(cls, digest):
-        return md5(bytes(digest, 'utf-8')).hexdigest()
-
-    def _set_hash_digest(self, digest):
-        self._webdav_left_digest_response_hash = self._hash_digest(digest)
-
-    def _get_hash_digest(self):
-        return self._webdav_left_digest_response_hash
-
-    webdav_left_digest_response_hash = synonym('_webdav_left_digest_response_hash',
-                                               descriptor=property(_get_hash_digest,
-                                                                   _set_hash_digest))
-
-    def update_webdav_digest_auth(self, cleartext_password: str) -> None:
-        self.webdav_left_digest_response_hash \
-            = '{username}:/:{cleartext_password}'.format(
-                username=self.email,
-                cleartext_password=cleartext_password,
-            )
 
     def validate_password(self, cleartext_password: str) -> bool:
         """
             hash = sha256()
             hash.update((cleartext_password + self.password[:64]).encode('utf-8'))
             result = self.password[64:] == hash.hexdigest()
-            if result and not self.webdav_left_digest_response_hash:
-                self.update_webdav_digest_auth(cleartext_password)
         return result
 
     def get_display_name(self, remove_email_part: bool=False) -> str:

tracim/tracim/model/data.py

     - closed-deprecated
     """
 
+    COPY = 'copy'
     ARCHIVING = 'archiving'
     COMMENT = 'content-comment'
     CREATION = 'creation'
         'status-update': 'fa-random',
         'unarchiving': 'fa-file-archive-o',
         'undeletion': 'fa-trash-o',
-        'move': 'fa-arrows'
+        'move': 'fa-arrows',
+        'copy': 'fa-files-o',
     }
 
     _LABELS = {
         'status-update': l_('New status'),
         'unarchiving': l_('Item unarchived'),
         'undeletion': l_('Item undeleted'),
-        'move': l_('Item moved')
+        'move': l_('Item moved'),
+        'copy': l_('Item copied'),
     }
 
     def __init__(self, id):
                 cls.STATUS_UPDATE,
                 cls.UNARCHIVING,
                 cls.UNDELETION,
-                cls.MOVE]
+                cls.MOVE,
+                cls.COPY,
+                ]
 
 
 class ContentStatus(object):
                 return False
             return True
 
+        # TODO - G.M - 15-03-2018 - Choose only correct Content-type for origin
+        # Only content who can be copied need this
+        if item.type == ContentType.Any:
+            if 'origin' in properties.keys():
+                return True
         raise NotImplementedError
 
     @classmethod
         'is_archived',
         'is_deleted',
         'label',
-        'node',
         'owner',
         'owner_id',
         'parent',
 
         return new_rev
 
+    @classmethod
+    def copy(
+            cls,
+            revision: 'ContentRevisionRO',
+            parent: 'Content'
+    ) -> 'ContentRevisionRO':
+
+        copy_rev = cls()
+        import copy
+        copy_columns = cls._cloned_columns
+        for column_name in copy_columns:
+            # INFO - G-M - 15-03-2018 - set correct parent
+            if column_name == 'parent_id':
+                column_value = copy.copy(parent.id)
+            elif column_name == 'parent':
+                column_value = copy.copy(parent)
+            else:
+                column_value = copy.copy(getattr(revision, column_name))
+            setattr(copy_rev, column_name, column_value)
+
+        # copy attached_file
+        if revision.depot_file:
+            copy_rev.depot_file = FileIntent(
+                revision.depot_file.file.read(),
+                revision.file_name,
+                revision.file_mimetype,
+            )
+        return copy_rev
+
+
     def __setattr__(self, key: str, value: 'mixed'):
         """
         ContentRevisionUpdateError is raised if tried to update column and revision own identity
         revisions = sorted(self.revisions, key=lambda revision: revision.revision_id)
         return revisions[-1]
 
-    def new_revision(self) -> None:
+    def new_revision(self) -> ContentRevisionRO:
         """
         Return and assign to this content a new revision.
         If it's a new content, revision is totally new.
 
         return ContentType.sorted(types)
 
-    def get_history(self) -> '[VirtualEvent]':
+    def get_history(self, drop_empty_revision=False) -> '[VirtualEvent]':
         events = []
         for comment in self.get_comments():
             events.append(VirtualEvent.create_from_content(comment))
-        for revision in self.revisions:
+
+        revisions = sorted(self.revisions, key=lambda rev: rev.revision_id)
+        for revision in revisions:
+            # INFO - G.M - 09-03-2018 - Do not show file revision with empty
+            # file to have a more clear view of revision.
+            # Some webdav client create empty file before uploading, we must
+            # have possibility to not show the related revision
+            if drop_empty_revision:
+                if revision.depot_file and revision.depot_file.file.content_length == 0:  # nopep8
+                    # INFO - G.M - 12-03-2018 -Always show the last and
+                    # first revision.
+                    if revision != revisions[-1] and revision != revisions[0]:
+                        continue
+
             events.append(VirtualEvent.create_from_content_revision(revision))
 
         sorted_events = sorted(events,
         cid = content.content_id
         return url_template.format(wid=wid, fid=fid, ctype=ctype, cid=cid)
 
+    def copy(self, parent):
+        cpy_content = Content()
+        for rev in self.revisions:
+            cpy_rev = ContentRevisionRO.copy(rev, parent)
+            cpy_content.revisions.append(cpy_rev)
+        return cpy_content
+
 
 class RevisionReadStatus(DeclarativeBase):
 

tracim/tracim/model/serializers.py

             links=[],
             revision_nb = len(content.revisions),
             selected_revision='latest' if content.revision_to_serialize<=0 else content.revision_to_serialize,
-            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history()),
+            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history(drop_empty_revision=True)),  # nopep8
             is_editable=content.is_editable,
             is_deleted=content.is_deleted,
             is_archived=content.is_archived,
             workspace = context.toDict(item.workspace),
             comments = reversed(context.toDict(item.get_comments())),
             is_new=item.has_new_information_for(context.get_user()),
-            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history()),
+            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history(drop_empty_revision=True)),  # nopep8
             is_editable=item.is_editable,
             is_deleted=item.is_deleted,
             is_archived=item.is_archived,

tracim/tracim/public/_caldavzap/resource.js

 			newElement.addClass('r_operate');
 
     var uniqueIdForLabel = inputResource.displayvalue.replace('.', '') // remove the point so jquery doesn't consider it as 2 differents classes when used in a selector
+    // Côme - 2018/03/19 - added custom style to avoid the '...' for long workspace name that hide the entire name
+		var customStyle = 'display: inline-block;white-space: nowrap;text-overflow: ellipsis;overflow: hidden;vertical-align: top;width: 80%;'
 		newElement.html("\
       <div class='resourceCalDAVColor' style='background:"+inputResource.ecolor+"'></div>\
       <input type='text' class='colorPicker'/>\
       <input type='checkbox' name="+inputResource.uid+" />\
-      <div class='"+uniqueIdForLabel+"' style='display:inline-block'>"+inputResource.displayvalue+"</div>");
+      <div class='"+uniqueIdForLabel+"' style='"+customStyle+"'>"+inputResource.displayvalue+"</div>");
 
     // +$('<div/>').text(inputResource.displayvalue).html()); // legacy code
     $.ajax({

tracim/tracim/templates/workspace/getone.mak

             <div class="col-md-6">
                 <div class="input-group">
                     <span class="input-group-addon" style="width: 8em;"><i class="fa fa-fw fa-windows"></i> Windows</span>
-                    <div class="form-control webdavconfig__input">http://${webdav_url}</div>
+                    <div class="form-control webdavconfig__input">${website_protocol}://${webdav_url}</div>
                 </div>
                 <p></p>
                 <div class="input-group">
                     <span class="input-group-addon" style="width: 8em;"><i class="fa fa-fw fa-linux"></i> Linux</span>
-                    <div class="form-control webdavconfig__input">dav://${webdav_url}</div>
+                    <div class="form-control webdavconfig__input">${dav_protocol}://${webdav_url}</div>
                 </div>
             </div>
             <div class="col-md-6">

tracim/tracim/tests/command/user.py

         # Check webdav digest exist for this user
         user = DBSession.query(User)\
             .filter(User.email == 'new-user@algoo.fr').one()
-        ok_(user.webdav_left_digest_response_hash)
 
     def test_update_password(self):
         self._create_user('new-user@algoo.fr', 'toor')
         # Grab webdav digest
         user = DBSession.query(User) \
             .filter(User.email == 'new-user@algoo.fr').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         self._execute_command(
             UpdateUserCommand,
         # Grab new webdav digest to compare it
         user = DBSession.query(User) \
             .filter(User.email == 'new-user@algoo.fr').one()
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be different',
-        )
 
     def test_create_with_group(self):
         more_args = ['--add-to-group', 'managers', '--add-to-group', 'administrators']

tracim/tracim/tests/functional/test_admin.py

         ok_(user, msg="User should exist now")
         ok_(user.validate_password('password'))
 
-        # User must have webdav digest
-        ok_(user.webdav_left_digest_response_hash)
-
     def test_update_user_password(self):
         self._connect_user(
             'admin@admin.admin',
 
         user = DBSession.query(User) \
             .filter(User.email == 'an-other-email@test.local').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         self.app.post(
             '/admin/users/{user_id}/password?_method=PUT'.format(
         user = DBSession.query(User) \
             .filter(User.email == 'an-other-email@test.local').one()
         ok_(user.validate_password('new-password'))
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be updated',
-        )

tracim/tracim/tests/functional/test_user.py

 
         user = DBSession.query(User) \
             .filter(User.email == 'lawrence-not-real-email@fsf.local').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         try_post_user = self.app.post(
             '/user/{user_id}/password?_method=PUT'.format(
         user = DBSession.query(User) \
             .filter(User.email == 'lawrence-not-real-email@fsf.local').one()
         ok_(user.validate_password('new-password'))
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be updated',
-        )

tracim/tracim/tests/library/test_content_api.py

 from nose.tools import eq_, ok_
 from nose.tools import raises
 
+from depot.io.utils import FileIntent
 import transaction
 
 from tracim.lib.content import compare_content_for_sorting_by_type_and_name
         eq_('', c.label)
         eq_(ActionDescription.COMMENT, c.revision_type)
 
+    def test_unit_copy_file_different_label_different_parent_ok(self):
+        uapi = UserApi(None)
+        groups = [
+            GroupApi(None).get_one(Group.TIM_USER),
+            GroupApi(None).get_one(Group.TIM_MANAGER),
+            GroupApi(None).get_one(Group.TIM_ADMIN)
+        ]
+
+        user = uapi.create_user(
+            email='user1@user',
+            groups=groups,
+            save_now=True
+        )
+        user2 = uapi.create_user(
+            email='user2@user',
+            groups=groups,
+            save_now=True
+        )
+        workspace = WorkspaceApi(user).create_workspace(
+            'test workspace',
+            save_now=True
+        )
+        RoleApi(user).create_one(
+            user2,
+            workspace,
+            UserRoleInWorkspace.WORKSPACE_MANAGER,
+            with_notif=False
+        )
+        api = ContentApi(user)
+        foldera = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'folder a',
+            True
+        )
+        with DBSession.no_autoflush:
+            text_file = api.create(
+                content_type=ContentType.File,
+                workspace=workspace,
+                parent=foldera,
+                label='test_file',
+                do_save=False,
+            )
+            api.update_file_data(
+                text_file,
+                'test_file',
+                'text/plain',
+                b'test_content'
+            )
+
+        api.save(text_file, ActionDescription.CREATION)
+        api2 = ContentApi(user2)
+        workspace2 = WorkspaceApi(user2).create_workspace(
+            'test workspace2',
+            save_now=True
+        )
+        folderb = api2.create(
+            ContentType.Folder,
+            workspace2,
+            None,
+            'folder b',
+            True
+        )
+
+        api2.copy(
+            item=text_file,
+            new_parent=folderb,
+            new_label='test_file_copy'
+        )
+
+        transaction.commit()
+        text_file_copy = api2.get_one_by_label_and_parent(
+            'test_file_copy',
+            folderb,
+        )
+
+        assert text_file != text_file_copy
+        assert text_file_copy.content_id != text_file.content_id
+        assert text_file_copy.workspace_id == workspace2.workspace_id
+        assert text_file_copy.depot_file.file.read() == text_file.depot_file.file.read()   # nopep8
+        assert text_file_copy.depot_file.path != text_file.depot_file.path
+        assert text_file_copy.label == 'test_file_copy'
+        assert text_file_copy.type == text_file.type
+        assert text_file_copy.parent.content_id == folderb.content_id
+        assert text_file_copy.owner.user_id == user.user_id
+        assert text_file_copy.description == text_file.description
+        assert text_file_copy.file_extension == text_file.file_extension
+        assert text_file_copy.file_mimetype == text_file.file_mimetype
+        assert text_file_copy.revision_type == ActionDescription.COPY
+        assert len(text_file_copy.revisions) == len(text_file.revisions) + 1
+
+    def test_unit_copy_file__same_label_different_parent_ok(self):
+        uapi = UserApi(None)
+        groups = [GroupApi(None).get_one(Group.TIM_USER),
+                  GroupApi(None).get_one(Group.TIM_MANAGER),
+                  GroupApi(None).get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_user(
+            email='user1@user',
+            groups=groups,
+            save_now=True
+        )
+        user2 = uapi.create_user(
+            email='user2@user',
+            groups=groups,
+            save_now=True
+        )
+        workspace = WorkspaceApi(user).create_workspace(
+            'test workspace',
+            save_now=True
+        )
+        RoleApi(user).create_one(
+            user2,
+            workspace,
+            UserRoleInWorkspace.WORKSPACE_MANAGER,
+            with_notif=False
+        )
+        api = ContentApi(user)
+        foldera = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'folder a',
+            True
+        )
+        with DBSession.no_autoflush:
+            text_file = api.create(
+                content_type=ContentType.File,
+                workspace=workspace,
+                parent=foldera,
+                label='test_file',
+                do_save=False,
+            )
+            api.update_file_data(
+                text_file,
+                'test_file',
+                'text/plain',
+                b'test_content'
+            )
+
+        api.save(text_file, ActionDescription.CREATION)
+        api2 = ContentApi(user2)
+        workspace2 = WorkspaceApi(user2).create_workspace(
+            'test workspace2',
+            save_now=True
+        )
+        folderb = api2.create(
+            ContentType.Folder,
+            workspace2,
+            None,
+            'folder b',
+            True
+        )
+        api2.copy(
+            item=text_file,
+            new_parent=folderb,
+        )
+
+        transaction.commit()
+        text_file_copy = api2.get_one_by_label_and_parent(
+            'test_file',
+            folderb,
+        )
+
+        assert text_file != text_file_copy
+        assert text_file_copy.content_id != text_file.content_id
+        assert text_file_copy.workspace_id == workspace2.workspace_id
+        assert text_file_copy.depot_file.file.read() == text_file.depot_file.file.read()  # nopep8
+        assert text_file_copy.depot_file.path != text_file.depot_file.path
+        assert text_file_copy.label == text_file.label
+        assert text_file_copy.type == text_file.type
+        assert text_file_copy.parent.content_id == folderb.content_id
+        assert text_file_copy.owner.user_id == user.user_id
+        assert text_file_copy.description == text_file.description
+        assert text_file_copy.file_extension == text_file.file_extension
+        assert text_file_copy.file_mimetype == text_file.file_mimetype
+        assert text_file_copy.revision_type == ActionDescription.COPY
+        assert len(text_file_copy.revisions) == len(text_file.revisions) + 1
+
+    def test_unit_copy_file_different_label_same_parent_ok(self):
+        uapi = UserApi(None)
+        groups = [
+            GroupApi(None).get_one(Group.TIM_USER),
+            GroupApi(None).get_one(Group.TIM_MANAGER),
+            GroupApi(None).get_one(Group.TIM_ADMIN),
+        ]
+
+        user = uapi.create_user(
+            email='user1@user',
+            groups=groups,
+            save_now=True,
+        )
+        user2 = uapi.create_user(
+            email='user2@user',
+            groups=groups,
+            save_now=True
+        )
+        workspace = WorkspaceApi(user).create_workspace(
+            'test workspace',
+            save_now=True
+        )
+        RoleApi(user).create_one(
+            user2, workspace,
+            UserRoleInWorkspace.WORKSPACE_MANAGER,
+            with_notif=False
+        )
+        api = ContentApi(user)
+        foldera = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'folder a',
+            True
+        )
+        with DBSession.no_autoflush:
+            text_file = api.create(
+                content_type=ContentType.File,
+                workspace=workspace,
+                parent=foldera,
+                label='test_file',
+                do_save=False,
+            )
+            api.update_file_data(
+                text_file,
+                'test_file',
+                'text/plain',
+                b'test_content'
+            )
+
+        api.save(
+            text_file,
+            ActionDescription.CREATION
+        )
+        api2 = ContentApi(user2)
+
+        api2.copy(
+            item=text_file,
+            new_label='test_file_copy'
+        )
+
+        transaction.commit()
+        text_file_copy = api2.get_one_by_label_and_parent(
+            'test_file_copy',
+            foldera,
+        )
+
+        assert text_file != text_file_copy
+        assert text_file_copy.content_id != text_file.content_id
+        assert text_file_copy.workspace_id == workspace.workspace_id
+        assert text_file_copy.depot_file.file.read() == text_file.depot_file.file.read()  # nopep8
+        assert text_file_copy.depot_file.path != text_file.depot_file.path
+        assert text_file_copy.label == 'test_file_copy'
+        assert text_file_copy.type == text_file.type
+        assert text_file_copy.parent.content_id == foldera.content_id
+        assert text_file_copy.owner.user_id == user.user_id
+        assert text_file_copy.description == text_file.description
+        assert text_file_copy.file_extension == text_file.file_extension
+        assert text_file_copy.file_mimetype == text_file.file_mimetype
+        assert text_file_copy.revision_type == ActionDescription.COPY
+        assert len(text_file_copy.revisions) == len(text_file.revisions) + 1
 
     def test_mark_read__workspace(self):
         uapi = UserApi(None)

tracim/tracim/tests/library/test_webdav.py

             )
         )
 
+    def test_unit__move_and_rename_content__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            environ,
+        )
+
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'w1f1d1') \
+            .one()  # It must exist only one revision, cf fixtures
+        ok_(content_w1f1d1, msg='w1f1d1 should be exist')
+        content_w1f1d1_id = content_w1f1d1.content_id
+        content_w1f1d1_parent = content_w1f1d1.parent
+        eq_(
+            content_w1f1d1_parent.label,
+            'w1f1',
+            msg='field parent should be w1f1',
+        )
+
+        w1f1d1.moveRecursive('/w1/w1f2/w1f1d1_RENAMED.txt')
+
+        # Database content is moved
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id == content_w1f1d1_id) \
+            .order_by(ContentRevisionRO.revision_id.desc()) \
+            .first()
+        ok_(
+            content_w1f1d1.parent.label != content_w1f1d1_parent.label,
+            msg='file should be moved in w1f2 but is in {0}'.format(
+                content_w1f1d1.parent.label
+            )
+        )
+        eq_(
+            'w1f1d1_RENAMED',
+            content_w1f1d1.label,
+            msg='File should be labeled w1f1d1_RENAMED, not {0}'.format(
+                content_w1f1d1.label
+            )
+        )
+
     def test_unit__move_content__ok__another_workspace(self):
         provider = self._get_provider()
         environ = self._get_environ(

tracim/tracim/tests/models/test_content_revision.py

 class TestContentRevision(BaseTest, TestStandard):
 
     def _new_from(self, revision):
-        excluded_columns = ('revision_id', '_sa_instance_state', 'depot_file')
+        excluded_columns = (
+            'revision_id',
+            '_sa_instance_state',
+            'depot_file',
+            'node',
+            'revision_read_statuses',
+        )
         revision_columns = [attr.key for attr in inspect(revision).attrs if not attr.key in excluded_columns]
         new_revision = ContentRevisionRO()
 

tracim/wsgidav.conf.sample

 
 root_path = ''
 
+# Tracim doesn't support digest auth for webdav
+acceptbasic = True
+acceptdigest = False
+defaultdigest = False
 #===============================================================================
 # Lock Manager
 #