massive refactoring for better understanding of the code and sql schema. minor bugfixes + css improvments

doc/database/tracim-init-database.new.sql

+SET statement_timeout = 0;
+SET client_encoding = 'UTF8';
+SET standard_conforming_strings = on;
+SET check_function_bodies = false;
+SET client_min_messages = warning;
+
+CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog;
+COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';
+SET search_path = public, pg_catalog;
+
+CREATE FUNCTION update_node() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+BEGIN
+INSERT INTO content_revisions (content_id, parent_id, type, created, updated, 
+       label, description, status, 
+       file_name, file_content, file_mimetype, parent_tree_path, 
+       node_depth, owner_id, revision_id, workspace_id, is_deleted, is_archived, properties, revision_type) VALUES (NEW.content_id, NEW.parent_id, NEW.type, NEW.created, NEW.updated, NEW.label, NEW.description, NEW.status, NEW.file_name, NEW.file_content, NEW.file_mimetype, NEW.parent_tree_path, NEW.node_depth, NEW.owner_id, nextval('seq__content_revisions__revision_id'), NEW.workspace_id, NEW.is_deleted, NEW.is_archived, NEW.properties, NEW.revision_type);
+return new;
+END;
+$$;
+
+CREATE FUNCTION set_created() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+BEGIN
+    NEW.created = CURRENT_TIMESTAMP;
+    NEW.updated = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$;
+
+CREATE FUNCTION set_updated() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+BEGIN
+    NEW.updated = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$;
+
+SET default_tablespace = '';
+SET default_with_oids = false;
+
+CREATE TABLE migrate_version (
+    version_num character varying(32) NOT NULL
+);
+
+CREATE TABLE groups (
+    group_id integer NOT NULL,
+    group_name character varying(16) NOT NULL,
+    display_name character varying(255),
+    created timestamp without time zone
+);
+
+CREATE SEQUENCE seq__groups__group_id
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER SEQUENCE seq__groups__group_id OWNED BY groups.group_id;
+
+CREATE TABLE group_permission (
+    group_id integer NOT NULL,
+    permission_id integer NOT NULL
+);
+
+CREATE SEQUENCE seq__content_revisions__revision_id
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+CREATE TABLE content_revisions (
+    content_id integer NOT NULL,
+    parent_id integer,
+    type character varying(16) DEFAULT 'data'::character varying NOT NULL,
+    created timestamp without time zone,
+    updated timestamp without time zone,
+    label character varying(1024),
+    description text DEFAULT ''::text NOT NULL,
+    status character varying(32) DEFAULT 'new'::character varying,
+    file_name character varying(255),
+    file_content bytea,
+    file_mimetype character varying(255),
+    parent_tree_path character varying(255),
+    node_depth integer DEFAULT 0 NOT NULL,
+    owner_id integer,
+    revision_id integer DEFAULT nextval('seq__content_revisions__revision_id'::regclass) NOT NULL,
+    workspace_id integer,
+    is_deleted boolean DEFAULT false NOT NULL,
+    is_archived boolean DEFAULT false NOT NULL,
+    properties text,
+    revision_type character varying(32)
+);
+
+COMMENT ON COLUMN content_revisions.properties IS 'This column contain properties specific to a given type. these properties are json encoded (so there is no structure "a priori")';
+
+CREATE VIEW contents AS
+    SELECT DISTINCT ON (content_revisions.content_id) content_revisions.content_id, content_revisions.parent_id, content_revisions.type, content_revisions.created, content_revisions.updated, content_revisions.label, content_revisions.description, content_revisions.status, content_revisions.file_name, content_revisions.file_content, content_revisions.file_mimetype, content_revisions.parent_tree_path, content_revisions.node_depth, content_revisions.owner_id, content_revisions.workspace_id, content_revisions.is_deleted, content_revisions.is_archived, content_revisions.properties, content_revisions.revision_type FROM content_revisions ORDER BY content_revisions.content_id, content_revisions.updated DESC, content_revisions.created DESC;
+
+CREATE SEQUENCE seq__contents__content_id
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER SEQUENCE seq__contents__content_id OWNED BY content_revisions.content_id;
+
+CREATE TABLE permissions (
+    permission_id integer NOT NULL,
+    permission_name character varying(63) NOT NULL,
+    description character varying(255)
+);
+
+CREATE SEQUENCE seq__permissions__permission_id
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER SEQUENCE seq__permissions__permission_id OWNED BY permissions.permission_id;
+
+CREATE TABLE users (
+    user_id integer NOT NULL,
+    email character varying(255) NOT NULL,
+    display_name character varying(255),
+    password character varying(128),
+    created timestamp without time zone,
+    is_active boolean DEFAULT true NOT NULL
+);
+
+CREATE TABLE user_group (
+    user_id integer NOT NULL,
+    group_id integer NOT NULL
+);
+
+CREATE SEQUENCE seq__users__user_id
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER SEQUENCE seq__users__user_id OWNED BY users.user_id;
+
+CREATE TABLE user_workspace (
+    user_id integer NOT NULL,
+    workspace_id integer NOT NULL,
+    role integer
+);
+
+CREATE TABLE workspaces (
+    workspace_id integer NOT NULL,
+    label character varying(1024),
+    description text,
+    created timestamp without time zone,
+    updated timestamp without time zone,
+    is_deleted boolean DEFAULT false NOT NULL
+);
+
+CREATE SEQUENCE seq__workspaces__workspace_id
+    START WITH 11
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER TABLE ONLY groups ALTER COLUMN group_id SET DEFAULT nextval('seq__groups__group_id'::regclass);
+ALTER TABLE ONLY content_revisions ALTER COLUMN content_id SET DEFAULT nextval('seq__contents__content_id'::regclass);
+ALTER TABLE ONLY permissions ALTER COLUMN permission_id SET DEFAULT nextval('seq__permissions__permission_id'::regclass);
+ALTER TABLE ONLY users ALTER COLUMN user_id SET DEFAULT nextval('seq__users__user_id'::regclass);
+ALTER TABLE ONLY workspaces ALTER COLUMN workspace_id SET DEFAULT nextval('seq__workspaces__workspace_id'::regclass);
+
+-- COPY migrate_version (version_num) FROM stdin;
+
+INSERT INTO groups (group_id, group_name, display_name, created) VALUES
+(1, 'users',	'Users',	'2014-10-08 14:55:43.329136'),
+(2, 'managers',	'Global Managers',	'2014-10-08 14:55:43.329136'),
+(3, 'administrators',	'Administrators',	'2014-10-08 14:55:43.329136');
+
+SELECT pg_catalog.setval('seq__groups__group_id', 4, true);
+
+SELECT pg_catalog.setval('seq__contents__content_id', 1, true);
+
+SELECT pg_catalog.setval('seq__content_revisions__revision_id', 2568, true);
+
+SELECT pg_catalog.setval('seq__permissions__permission_id', 1, true);
+
+INSERT INTO users(user_id, email, display_name, password, created, is_active)
+VALUES(1, 'demo.michel@tracim.org', 'Michel', '1533a541f0f24746a21b622a88ee8a43ce0197fb73300f633f8860abdbd22e6b8ebb1542dc4bae072729f84b4f0020c37abc60dd769dec7951e4ab80d10ce39e', '2014-10-23 15:28:56.268502', 't');
+
+INSERT INTO user_group(user_id, group_id) VALUES (1,1), (1, 2), (1,3);
+
+SELECT pg_catalog.setval('seq__users__user_id', 2, true);
+
+SELECT pg_catalog.setval('seq__workspaces__workspace_id', 1, true);
+
+ALTER TABLE ONLY user_workspace
+    ADD CONSTRAINT pk__user_workspace__user_id__workspace_id PRIMARY KEY (user_id, workspace_id);
+
+ALTER TABLE ONLY workspaces
+    ADD CONSTRAINT pk__workspace__workspace_id PRIMARY KEY (workspace_id);
+
+ALTER TABLE ONLY groups
+    ADD CONSTRAINT uk__groups__group_name UNIQUE (group_name);
+
+ALTER TABLE ONLY group_permission
+    ADD CONSTRAINT pk__group_permission__group_id__permission_id PRIMARY KEY (group_id, permission_id);
+
+ALTER TABLE ONLY groups
+    ADD CONSTRAINT pk__groups__group_id PRIMARY KEY (group_id);
+
+ALTER TABLE ONLY content_revisions
+    ADD CONSTRAINT pk__content_revisions__revision_id PRIMARY KEY (revision_id);
+
+ALTER TABLE ONLY permissions
+    ADD CONSTRAINT uk__permissions__permission_name UNIQUE (permission_name);
+
+ALTER TABLE ONLY permissions
+    ADD CONSTRAINT pk__permissions__permission_id PRIMARY KEY (permission_id);
+
+ALTER TABLE ONLY users
+    ADD CONSTRAINT uk__users__email UNIQUE (email);
+
+ALTER TABLE ONLY user_group
+    ADD CONSTRAINT pk__user_group__user_id__group_id PRIMARY KEY (user_id, group_id);
+
+ALTER TABLE ONLY users
+    ADD CONSTRAINT pk__users__user_id PRIMARY KEY (user_id);
+
+CREATE INDEX idx__content_revisions__owner_id ON content_revisions USING btree (owner_id);
+
+CREATE INDEX idx__content_revisions__parent_id ON content_revisions USING btree (parent_id);
+
+CREATE INDEX idx__content_revisions__parent_tree_path ON content_revisions USING btree (parent_tree_path);
+
+CREATE RULE rul__insert__new_node AS ON INSERT TO contents DO INSTEAD INSERT INTO content_revisions (content_id, parent_id, type, created, updated, label, description, status, file_name, file_content, file_mimetype, parent_tree_path, node_depth, owner_id, revision_id, workspace_id, is_deleted, is_archived, properties, revision_type) VALUES (nextval('seq__contents__content_id'::regclass), new.parent_id, new.type, new.created, new.updated, new.label, new.description, new.status, new.file_name, new.file_content, new.file_mimetype, new.parent_tree_path, new.node_depth, new.owner_id, nextval('seq__content_revisions__revision_id'::regclass), new.workspace_id, new.is_deleted, new.is_archived, new.properties, new.revision_type) RETURNING content_revisions.content_id, content_revisions.parent_id, content_revisions.type, content_revisions.created, content_revisions.updated, content_revisions.label, content_revisions.description, content_revisions.status, content_revisions.file_name, content_revisions.file_content, content_revisions.file_mimetype, content_revisions.parent_tree_path, content_revisions.node_depth, content_revisions.owner_id, content_revisions.workspace_id, content_revisions.is_deleted, content_revisions.is_archived, content_revisions.properties, content_revisions.revision_type;
+
+CREATE TRIGGER trg__contents__on_insert__set_created BEFORE INSERT ON content_revisions FOR EACH ROW EXECUTE PROCEDURE set_created();
+CREATE TRIGGER trg__contents__on_update__set_updated BEFORE UPDATE ON content_revisions FOR EACH ROW EXECUTE PROCEDURE set_updated();
+
+CREATE TRIGGER trg__contents__on_update INSTEAD OF UPDATE ON contents FOR EACH ROW EXECUTE PROCEDURE update_node();
+CREATE TRIGGER trg__workspaces__on_insert__set_created BEFORE INSERT ON workspaces FOR EACH ROW EXECUTE PROCEDURE set_created();
+CREATE TRIGGER trg__workspaces__on_update__set_updated BEFORE UPDATE ON workspaces FOR EACH ROW EXECUTE PROCEDURE set_updated();
+
+ALTER TABLE ONLY user_workspace
+    ADD CONSTRAINT fk__user_workspace__user_id FOREIGN KEY (user_id) REFERENCES users(user_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+ALTER TABLE ONLY user_workspace
+    ADD CONSTRAINT fk__user_workspace__workspace_id FOREIGN KEY (workspace_id) REFERENCES workspaces(workspace_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+ALTER TABLE ONLY group_permission
+    ADD CONSTRAINT fk__group_permission__group_id FOREIGN KEY (group_id) REFERENCES groups(group_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+ALTER TABLE ONLY group_permission
+    ADD CONSTRAINT fk__group_permission__permission_id FOREIGN KEY (permission_id) REFERENCES permissions(permission_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+ALTER TABLE ONLY content_revisions
+    ADD CONSTRAINT fk__content_revisions__owner_id FOREIGN KEY (owner_id) REFERENCES users(user_id);
+
+ALTER TABLE ONLY user_group
+    ADD CONSTRAINT fk__user_group__group_id FOREIGN KEY (group_id) REFERENCES groups(group_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+ALTER TABLE ONLY user_group
+    ADD CONSTRAINT fk__user_group__user_id FOREIGN KEY (user_id) REFERENCES users(user_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+

install/requirements.txt

 Pillow==2.4.0
 SQLAlchemy==0.9.4
 Tempita==0.5.3dev
-TurboGears2==2.3.3
+TurboGears2==2.3.4
 WebOb==1.4
 WebTest==1.4.3
 alembic==0.6.5

tracim/tracim/config/app_cfg.py

     def __init__(self, sa_auth):
         self.sa_auth = sa_auth
     def authenticate(self, environ, identity):
-        user = self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(self.sa_auth.user_class.is_active==True, self.sa_auth.user_class.email_address==identity['login'])).first()
+        user = self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(self.sa_auth.user_class.is_active==True, self.sa_auth.user_class.email==identity['login'])).first()
         if user and user.validate_password(identity['password']):
             return identity['login']
     def get_user(self, identity, userid):
-        return self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(self.sa_auth.user_class.is_active==True, self.sa_auth.user_class.email_address==userid)).first()
+        return self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(self.sa_auth.user_class.is_active==True, self.sa_auth.user_class.email==userid)).first()
     def get_groups(self, identity, userid):
         return [g.group_name for g in identity['user'].groups]
     def get_permissions(self, identity, userid):
 # INFO - This is the way to specialize the resetpassword email properties
 # plug(base_config, 'resetpassword', None, mail_subject=reset_password_email_subject)
 plug(base_config, 'resetpassword', 'reset_password')
+
+def fake_unicode(some_string_or_bytes):
+    return some_string_or_bytes
+    if isinstance(some_string_or_bytes, str):
+        print("IS STRING")
+        return some_string_or_bytes
+
+    print("IS ", some_string_or_bytes.__class__.__name__)
+    return str(some_string_or_bytes, 'utf-8')
+#     if isinstance(some_string_or_bytes, bytes):
+#         return some_string_or_bytes.encode('utf-8')
+#     return some_string_or_bytes
+#
+import resetpassword.lib as rplib
+# rplib.unicode = fake_unicode
+
 replace_template(base_config, 'resetpassword.templates.index', 'tracim.templates.reset_password_index')
-replace_template(base_config, 'resetpassword.templates.change_password', 'tracim.templates.reset_password_change_password')
+replace_template(base_config, 'resetpassword.templates.change_password', 'mako:tracim.templates.reset_password_change_password')
 
 # Note: here are fake translatable strings that allow to translate messages for reset password email content
 duplicated_email_subject = l_('Password reset request')

tracim/tracim/controllers/__init__.py

 from tracim.model.auth import User
 from tracim.model.data import ActionDescription
 from tracim.model.data import BreadcrumbItem
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import Workspace
 
 from tracim.lib.content import ContentApi
 
 
     @classmethod
-    def current_folder(cls) -> PBNode:
+    def current_folder(cls) -> Content:
         content_api = ContentApi(tg.tmpl_context.current_user)
         folder_id = int(tg.request.controller_state.routing_args.get('folder_id'))
-        folder = content_api.get_one(folder_id, PBNodeType.Folder, tg.tmpl_context.workspace)
+        folder = content_api.get_one(folder_id, ContentType.Folder, tg.tmpl_context.workspace)
 
         tg.tmpl_context.folder_id = folder_id
         tg.tmpl_context.folder = folder
 
 
     @classmethod
-    def current_folder(cls) -> PBNode:
+    def current_folder(cls) -> Content:
         content_api = ContentApi(tg.tmpl_context.current_user)
         folder_id = int(tg.request.controller_state.routing_args.get('folder_id'))
-        folder = content_api.get_one(folder_id, PBNodeType.Folder, tg.tmpl_context.workspace)
+        folder = content_api.get_one(folder_id, ContentType.Folder, tg.tmpl_context.workspace)
 
         tg.tmpl_context.folder_id = folder_id
         tg.tmpl_context.folder = folder
 
 
     @classmethod
-    def _current_item_manually(cls, item_id: int, item_type: str) -> PBNode:
+    def _current_item_manually(cls, item_id: int, item_type: str) -> Content:
         # in case thread or page or other stuff is instanciated, then force
         # the associated item to be available through generic name tmpl_context.item to be available
         content_api = ContentApi(tg.tmpl_context.current_user)
         item = content_api.get_one(item_id, item_type, tg.tmpl_context.workspace)
 
-        tg.tmpl_context.item_id = item.node_id
+        tg.tmpl_context.item_id = item.content_id
         tg.tmpl_context.item = item
 
         return item
 
 
     @classmethod
-    def current_thread(cls) -> PBNode:
+    def current_thread(cls) -> Content:
         thread_id = int(tg.request.controller_state.routing_args.get('thread_id'))
-        thread = cls._current_item_manually(thread_id, PBNodeType.Thread)
-        tg.tmpl_context.thread_id = thread.node_id
+        thread = cls._current_item_manually(thread_id, ContentType.Thread)
+        tg.tmpl_context.thread_id = thread.content_id
         tg.tmpl_context.thread = thread
         return thread
 
 
     @classmethod
-    def current_page(cls) -> PBNode:
+    def current_page(cls) -> Content:
         page_id = int(tg.request.controller_state.routing_args.get('page_id'))
-        page = cls._current_item_manually(page_id, PBNodeType.Page)
-        tg.tmpl_context.page_id = page.node_id
+        page = cls._current_item_manually(page_id, ContentType.Page)
+        tg.tmpl_context.page_id = page.content_id
         tg.tmpl_context.page = page
         return page
 
         workspace_id = tmpl_context.workspace_id
         breadcrumb = []
 
-        breadcrumb.append(BreadcrumbItem(PBNodeType.icon(PBNodeType.FAKE_Dashboard), _('Workspaces'), tg.url('/workspaces')))
-        breadcrumb.append(BreadcrumbItem(PBNodeType.icon(PBNodeType.FAKE_Workspace), workspace.data_label, tg.url('/workspaces/{}'.format(workspace.workspace_id))))
+        breadcrumb.append(BreadcrumbItem(ContentType.icon(ContentType.FAKE_Dashboard), _('Workspaces'), tg.url('/workspaces')))
+        breadcrumb.append(BreadcrumbItem(ContentType.icon(ContentType.FAKE_Workspace), workspace.label, tg.url('/workspaces/{}'.format(workspace.workspace_id))))
 
         content_api = ContentApi(tmpl_context.current_user)
         if folder_id:
             breadcrumb_folder_items = []
-            current_item = content_api.get_one(folder_id, PBNodeType.Any, workspace)
+            current_item = content_api.get_one(folder_id, ContentType.Any, workspace)
             is_active = True
 
             while current_item:
-                breadcrumb_item = BreadcrumbItem(PBNodeType.icon(current_item.node_type),
-                                                 current_item.data_label,
-                                                 tg.url('/workspaces/{}/folders/{}'.format(workspace_id, current_item.node_id)),
+                breadcrumb_item = BreadcrumbItem(ContentType.icon(current_item.type),
+                                                 current_item.label,
+                                                 tg.url('/workspaces/{}/folders/{}'.format(workspace_id, current_item.content_id)),
                                                  is_active)
                 is_active = False # the first item is True, then all other are False => in the breadcrumb, only the last item is "active"
                 breadcrumb_folder_items.append(breadcrumb_item)
 
             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.node_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))
             content_api.save(item, ActionDescription.STATUS_UPDATE)
             msg = _('{} status updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
-            tg.redirect(self._std_url.format(item.workspace_id, item.parent_id, item.node_id))
+            tg.redirect(self._std_url.format(item.workspace_id, item.parent_id, item.content_id))
         except ValueError as e:
             msg = _('{} status not updated: {}').format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
-            tg.redirect(self._err_url.format(item.workspace_id, item.parent_id, item.node_id))
+            tg.redirect(self._err_url.format(item.workspace_id, item.parent_id, item.content_id))
 
 
-    def get_all_fake(self, context_workspace: Workspace, context_folder: PBNode) -> [PBNode]:
+    def get_all_fake(self, context_workspace: Workspace, context_folder: Content) -> [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
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        items = content_api.get_all(context_folder.node_id, self._item_type, workspace)
+        items = content_api.get_all(context_folder.content_id, self._item_type, workspace)
 
         dictified_items = Context(self._get_all_context).toDict(items)
         return DictLikeClass(result = dictified_items)
         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.parent_id, item.node_id)+'/put_archive_undo'
+            undo_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)+'/put_archive_undo'
             msg = _('{} archived. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
 
             content_api.archive(item)
             tg.flash(msg, CST.STATUS_OK, no_escape=True) # TODO allow to come back
             tg.redirect(next_url)
         except ValueError as e:
-            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.node_id)
+            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)
         content_api = ContentApi(tmpl_context.current_user, True) # Here we do not filter archived items
         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)
+            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             msg = _('{} unarchived.').format(self._item_type_label)
             content_api.unarchive(item)
             content_api.save(item, ActionDescription.UNARCHIVING)
 
         except ValueError as e:
             msg = _('{} not un-archived: {}').format(self._item_type_label, str(e))
-            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.node_id)
+            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             # We still use std url because the item has not been archived
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(next_url)
         try:
 
             next_url = self._parent_url.format(item.workspace_id, item.parent_id)
-            undo_url = self._std_url.format(item.workspace_id, item.parent_id, item.node_id)+'/put_delete_undo'
+            undo_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)+'/put_delete_undo'
             msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
             content_api.delete(item)
             content_api.save(item, ActionDescription.DELETION)
             tg.redirect(next_url)
 
         except ValueError as e:
-            back_url = self._std_url.format(item.workspace_id, item.parent_id, item.node_id)
+            back_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             msg = _('{} not deleted: {}').format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
         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)
         try:
-            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.node_id)
+            next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             msg = _('{} undeleted.').format(self._item_type_label)
             content_api.undelete(item)
             content_api.save(item, ActionDescription.UNDELETION)

tracim/tracim/controllers/admin/user.py

 
     @tg.require(predicates.in_group(Group.TIM_MANAGER_GROUPNAME))
     @tg.expose()
-    def post(self, name, email, password, is_tracim_manager='off', is_pod_admin='off'):
+    def post(self, name, email, password, is_tracim_manager='off', is_tracim_admin='off'):
         is_tracim_manager = h.on_off_to_boolean(is_tracim_manager)
-        is_tracim_admin = h.on_off_to_boolean(is_pod_admin)
+        is_tracim_admin = h.on_off_to_boolean(is_tracim_admin)
         current_user = tmpl_context.current_user
-        current_user = User()
+
         if current_user.profile.id < Group.TIM_ADMIN:
             # A manager can't give large rights
             is_tracim_manager = False
             tg.redirect(self.url())
 
         user = api.create_user()
-        user.email_address = email
+        user.email = email
         user.display_name = name
         if password:
             user.password = password

tracim/tracim/controllers/admin/workspace.py

 
 from tracim.model.auth import Group
 from tracim.model.data import NodeTreeItem
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import Workspace
 from tracim.model.data import UserRoleInWorkspace
 
 
         tg.flash(flash_msg_template.format(
             role.user.get_display_name(),
-            tg.tmpl_context.workspace.data_label,
+            tg.tmpl_context.workspace.label,
             role.role_as_label()), CST.STATUS_OK)
 
         tg.redirect(self.parent_controller.url(tg.tmpl_context.workspace_id))
 
         workspace = workspace_api_controller.create_workspace(name, description)
 
-        tg.flash(_('{} workspace created.').format(workspace.data_label), CST.STATUS_OK)
+        tg.flash(_('{} workspace created.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url())
         return
 
         workspace_api_controller = WorkspaceApi(user)
 
         workspace = workspace_api_controller.get_one(id)
-        workspace.data_label = name
-        workspace.data_comment = description
+        workspace.label = name
+        workspace.description = description
         workspace_api_controller.save(workspace)
 
-        tg.flash(_('{} workspace updated.').format(workspace.data_label), CST.STATUS_OK)
+        tg.flash(_('{} workspace updated.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url(workspace.workspace_id))
         return
 
         workspace = api.get_one(workspace_id)
         api.delete_one(workspace_id)
 
-        workspace_label = workspace.data_label
+        workspace_label = workspace.label
         undo_url = self.url(workspace_id, self.restore.__name__)
 
         tg.flash(_('{} workspace deleted. In case of error, you can <a class="alert-link" href="{}">restore it</a>.').format(workspace_label, undo_url), CST.STATUS_OK, no_escape=True)
         api = WorkspaceApi(tg.tmpl_context.current_user)
         workspace = api.restore_one(workspace_id, True)
 
-        workspace_label = workspace.data_label
+        workspace_label = workspace.label
         undo_url = self.url(workspace_id, 'delete')
 
         tg.flash(_('{} workspace restored.').format(workspace_label), CST.STATUS_OK)

tracim/tracim/controllers/content.py

 
 from tracim.model.serializers import Context, CTX, DictLikeClass
 from tracim.model.data import ActionDescription
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import Workspace
 
 
 
     @property
     def _item_type(self):
-        return PBNodeType.File
+        return ContentType.File
 
     @property
     def _item_type_label(self):
                 if not revision_to_send:
                     revision_to_send = revision
 
-                if revision.version_id>revision_to_send.version_id:
+                if revision.revision_id>revision_to_send.revision_id:
                     revision_to_send = revision
         else:
             for revision in item.revisions:
-                if revision.version_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.data_file_mime_type:
-            content_type = str(revision_to_send.data_file_mime_type)
-            tg.response.headers['Content-type'] = str(revision_to_send.data_file_mime_type)
+        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'] = content_type
-        tg.response.headers['Content-Disposition'] = str('attachment; filename="{}"'.format(revision_to_send.data_file_name))
-        return revision_to_send.data_file_content
+        tg.response.headers['Content-Disposition'] = str('attachment; filename="{}"'.format(revision_to_send.file_name))
+        return revision_to_send.file_content
 
 
-    def get_all_fake(self, context_workspace: Workspace, context_folder: PBNode):
+    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
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        files = content_api.get_all(context_folder.node_id, PBNodeType.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)
 
         api = ContentApi(tmpl_context.current_user)
 
-        file = api.create(PBNodeType.File, workspace, tmpl_context.folder, label)
+        file = api.create(ContentType.File, workspace, tmpl_context.folder, label)
         api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
         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.node_id))
+        tg.redirect(tg.url('/workspaces/{}/folders/{}/files/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, file.content_id))
 
 
     @tg.require(current_user_is_contributor())
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(int(item_id), self._item_type, workspace)
             if comment:
-                api.update_content(item, label if label else item.data_label, comment)
+                api.update_content(item, label if label else item.label, comment)
 
             if isinstance(file_data, FieldStorage):
                 api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
 
             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.node_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))
 
     @property
     def _item_type(self):
-        return PBNodeType.Page
+        return ContentType.Page
 
     @property
     def _item_type_label(self):
 
         content_api = ContentApi(user)
         if revision_id:
-            page = content_api.get_one_from_revision(page_id, PBNodeType.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, PBNodeType.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)
         return DictLikeClass(result = dictified_page, fake_api=fake_api)
 
 
-    def get_all_fake(self, context_workspace: Workspace, context_folder: PBNode):
+    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
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        pages = content_api.get_all(context_folder.node_id, PBNodeType.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)
 
         api = ContentApi(tmpl_context.current_user)
 
-        page = api.create(PBNodeType.Page, workspace, tmpl_context.folder, label)
-        page.data_content = content
+        page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
+        page.description = content
         api.save(page, ActionDescription.CREATION)
 
         tg.flash(_('Page created'), CST.STATUS_OK)
-        tg.redirect(tg.url('/workspaces/{}/folders/{}/pages/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, page.node_id))
+        tg.redirect(tg.url('/workspaces/{}/folders/{}/pages/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, page.content_id))
 
 
 
 
     @property
     def _item_type(self):
-        return PBNodeType.Thread
+        return ContentType.Thread
 
 
     @property
 
         api = ContentApi(tmpl_context.current_user)
 
-        thread = api.create(PBNodeType.Thread, workspace, tmpl_context.folder, label)
-        # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.data_content = 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)
 
-        comment = api.create(PBNodeType.Comment, workspace, thread, label)
-        comment.data_label = ''
-        comment.data_content = content
+        comment = api.create(ContentType.Comment, workspace, thread, label)
+        comment.label = ''
+        comment.description = content
         api.save(comment, ActionDescription.COMMENT)
 
         tg.flash(_('Thread created'), CST.STATUS_OK)
-        tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, thread.node_id))
+        tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, thread.content_id))
 
 
     @tg.require(current_user_is_reader())
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
         content_api = ContentApi(user)
-        thread = content_api.get_one(thread_id, PBNodeType.Thread, workspace)
+        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)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
 
-        item = ContentApi(user).get_one(item_id, PBNodeType.Any, workspace)
+        item = ContentApi(user).get_one(item_id, ContentType.Any, workspace)
         raise NotImplementedError
         return item
 
         workspace = tmpl_context.workspace
 
         content_api = ContentApi(user)
-        item = content_api.get_one(item_id, PBNodeType.Any, workspace)
+        item = content_api.get_one(item_id, ContentType.Any, workspace)
 
         dictified_item = Context(CTX.DEFAULT).toDict(item, 'item')
         return DictLikeClass(result = dictified_item)
         new_workspace, new_parent = convert_id_into_instances(folder_id)
 
         api = ContentApi(tmpl_context.current_user)
-        item = api.get_one(item_id, PBNodeType.Any, workspace)
+        item = api.get_one(item_id, ContentType.Any, workspace)
         api.move(item, new_parent)
         next_url = self.parent_controller.url(item_id)
         if new_parent:
-            tg.flash(_('Item moved to {}').format(new_parent.data_label), CST.STATUS_OK)
+            tg.flash(_('Item moved to {}').format(new_parent.label), CST.STATUS_OK)
         else:
             tg.flash(_('Item moved to workspace root'))
 
         workspace = tmpl_context.workspace
 
         content_api = ContentApi(user)
-        folder = content_api.get_one(folder_id, PBNodeType.Folder, workspace)
+        folder = content_api.get_one(folder_id, ContentType.Folder, workspace)
 
         dictified_folder = Context(CTX.FOLDER).toDict(folder, 'folder')
         return DictLikeClass(result = dictified_folder)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
         content_api = ContentApi(user)
-        folder = content_api.get_one(folder_id, PBNodeType.Folder, workspace)
+        folder = content_api.get_one(folder_id, ContentType.Folder, workspace)
 
         fake_api_breadcrumb = self.get_breadcrumb(folder_id)
-        fake_api_subfolders = self.get_all_fake(workspace, folder.node_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
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        parent_folder = content_api.get_one(parent_id, PBNodeType.Folder)
+        parent_folder = content_api.get_one(parent_id, ContentType.Folder)
         folders = content_api.get_child_folders(parent_folder, workspace)
 
         folders = Context(CTX.FOLDERS).toDict(folders)
         try:
             parent = None
             if parent_id:
-                parent = api.get_one(int(parent_id), PBNodeType.Folder, workspace)
-            folder = api.create(PBNodeType.Folder, workspace, parent, label)
+                parent = api.get_one(int(parent_id), ContentType.Folder, workspace)
+            folder = api.create(ContentType.Folder, workspace, parent, label)
 
             subcontent = dict(
                 folder = True if can_contain_folders=='on' else False,
             api.save(folder)
 
             tg.flash(_('Folder created'), CST.STATUS_OK)
-            redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, folder.node_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.')
             traceback.print_exc()
         next_url = ''
 
         try:
-            folder = api.get_one(int(folder_id), PBNodeType.Folder, workspace)
+            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
             )
-            api.update_content(folder, label, folder.data_content)
+            api.update_content(folder, label, folder.description)
             api.set_allowed_content(folder, subcontent)
             api.save(folder)
 
             tg.flash(_('Folder updated'), CST.STATUS_OK)
 
-            next_url = self.url(folder.node_id)
+            next_url = self.url(folder.content_id)
 
         except Exception as e:
             tg.flash(_('Folder not updated: {}').format(str(e)), CST.STATUS_ERROR)

tracim/tracim/controllers/help.py

         # FIXME - NOT REALLY SAFE BECAUSE SOME UNWANTED FILE MAY BE USED AS HELP PAGE
         if help_page:
             help_page_path = 'mako:tracim.templates.help.page-{}'.format(help_page)
-            print('TEMPLATE:', help_page_path)
             override_template(HelpController.page, help_page_path)
 
         return dict(mode=mode)

tracim/tracim/controllers/workspace.py

 from tracim.lib.workspace import WorkspaceApi
 
 from tracim.model.data import NodeTreeItem
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import Workspace
 from tracim.model.data import UserRoleInWorkspace
 
             return dictified_workspaces
 
 
-        allowed_content_types = PBNodeType.allowed_types_from_str(folder_allowed_content_types)
+        allowed_content_types = ContentType.allowed_types_from_str(folder_allowed_content_types)
         ignored_item_ids = [int(ignore_id)] if ignore_id else []
 
         # Now complex case: we must return a structured tree
 
     def _build_sibling_list_of_tree_items(self,
                                           workspace: Workspace,
-                                          content: PBNode,
+                                          content: Content,
                                           children: [NodeTreeItem],
                                           select_active_node = False,
                                           allowed_content_types: list = [],
-                                          ignored_item_ids: list = []) -> (PBNode, [NodeTreeItem]):
+                                          ignored_item_ids: list = []) -> (Content, [NodeTreeItem]):
         api = ContentApi(tmpl_context.current_user)
         tree_items = []
 

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

 msgstr ""
 "Project-Id-Version: pod 0.1\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
-"POT-Creation-Date: 2014-10-23 15:20+0200\n"
-"PO-Revision-Date: 2014-10-22 19:26+0100\n"
+"POT-Creation-Date: 2014-10-24 13:36+0200\n"
+"PO-Revision-Date: 2014-10-24 13:36+0100\n"
 "Last-Translator: Damien Accorsi <damien.accorsi@free.fr>\n"
 "Language-Team: fr_FR <LL@li.org>\n"
 "Plural-Forms: nplurals=2; plural=(n > 1)\n"
 "\n"
 "%(password_reset_link)s\n"
 "\n"
-"If you no longer wish to make the above change, or if you did not "
-"initiate this request, please disregard and/or delete this e-mail.\n"
+"If you no longer wish to make the above change, or if you did not initiate this request, please disregard and/or delete this e-mail.\n"
 msgstr ""
 "\n"
-"Nous avons reçu une requête de réinitialisation du mot de passe pour ce "
-"compte utilisateur.\n"
+"Nous avons reçu une requête de réinitialisation du mot de passe pour ce compte utilisateur.\n"
 "Cliquer sur le lien ci-dessous pour réinitialiser votre mot de passe :\n"
 "\n"
 "%(password_reset_link)s\n"
 "\n"
-"Si vous ne souhaitez plus procéder à ce changement, ou si vous n'êtes pas"
-" à l'originie de cette requête, merci d'ignorer et/ou supprimer cet "
-"e-mail.\n"
+"Si vous ne souhaitez plus procéder à ce changement, ou si vous n'êtes pas à l'originie de cette requête, merci d'ignorer et/ou supprimer cet e-mail.\n"
 
 #: tracim/controllers/__init__.py:139
 #: tracim/templates/master_authenticated.mak:87
 #: tracim/templates/master_no_toolbar_no_login.mak:112
-#: tracim/templates/user_get_one.mak:39 tracim/templates/user_profile.mak:39
+#: tracim/templates/user_get_one.mak:39
+#: tracim/templates/user_profile.mak:39
 #: tracim/templates/user_workspace_folder_file_get_one.mak:10
 #: tracim/templates/user_workspace_folder_get_one.mak:11
 #: tracim/templates/user_workspace_folder_page_get_one.mak:11
 msgid "Workspaces"
 msgstr "Espaces de travail"
 
-#: tracim/controllers/__init__.py:274 tracim/controllers/content.py:206
+#: tracim/controllers/__init__.py:274
+#: tracim/controllers/content.py:206
 msgid "{} updated"
 msgstr "{} mis(e) à jour"
 
-#: tracim/controllers/__init__.py:279 tracim/controllers/content.py:211
+#: tracim/controllers/__init__.py:279
+#: tracim/controllers/content.py:211
 msgid "{} not updated - error: {}"
 msgstr "{} pas mis(e) à jour - erreur : {}"
 
 
 #: tracim/controllers/__init__.py:378
 msgid "{} deleted. <a class=\"alert-link\" href=\"{}\">Cancel action</a>"
-msgstr ""
-"{} supprimé(e). <a class=\"alert-link\" href=\"{}\">Annuler "
-"l'opération</a>"
+msgstr "{} supprimé(e). <a class=\"alert-link\" href=\"{}\">Annuler l'opération</a>"
 
 #: tracim/controllers/__init__.py:387
 msgid "{} not deleted: {}"
 msgid "Successfully logged out. We hope to see you soon!"
 msgstr "Déconnexion réussie. Nous espérons vous revoir bientôt !"
 
-#: tracim/controllers/user.py:64 tracim/controllers/admin/user.py:186
+#: tracim/controllers/user.py:64
+#: tracim/controllers/admin/user.py:201
 msgid "Empty password is not allowed."
 msgstr "Le mot de passe ne doit pas être vide"
 
-#: tracim/controllers/user.py:68 tracim/controllers/admin/user.py:190
+#: tracim/controllers/user.py:68
+#: tracim/controllers/admin/user.py:205
 msgid "The current password you typed is wrong"
 msgstr "Le mot de passe que vous avez tapé est erroné"
 
-#: tracim/controllers/user.py:72 tracim/controllers/admin/user.py:194
+#: tracim/controllers/user.py:72
+#: tracim/controllers/admin/user.py:209
 msgid "New passwords do not match."
 msgstr "Les mots de passe ne concordent pas"
 
-#: tracim/controllers/user.py:78 tracim/controllers/admin/user.py:200
+#: tracim/controllers/user.py:78
+#: tracim/controllers/admin/user.py:215
 msgid "Your password has been changed"
 msgstr "Votre mot de passe a été changé"
 
 msgid "profile updated."
 msgstr "Profil mis à jour"
 
-#: tracim/controllers/admin/user.py:73
+#: tracim/controllers/admin/user.py:84
 msgid "You can't change your own profile"
 msgstr "Vous ne pouvez pas changer votre propre profil"
 
-#: tracim/controllers/admin/user.py:80
+#: tracim/controllers/admin/user.py:91
+#: tracim/controllers/admin/user.py:142
 msgid "Unknown profile"
 msgstr "Profil inconnu"
 
-#: tracim/controllers/admin/user.py:87
+#: tracim/controllers/admin/user.py:98
 msgid "User updated."
 msgstr "Utilisateur mis à jour"
 
-#: tracim/controllers/admin/user.py:103
+#: tracim/controllers/admin/user.py:114
 msgid "User {} is now a basic user"
 msgstr "L'utilisateur {} est désormais un utilisateur standard"
 
-#: tracim/controllers/admin/user.py:116
+#: tracim/controllers/admin/user.py:127
 msgid "User {} can now workspaces"
 msgstr "L'utilisateur {} peut désormais créer des espaces de travail"
 
-#: tracim/controllers/admin/user.py:127
+#: tracim/controllers/admin/user.py:138
 msgid "User {} is now an administrator"
 msgstr "L'utilisateur {} est désormais administrateur"
 
-#: tracim/controllers/admin/user.py:248
+#: tracim/controllers/admin/user.py:263
 msgid "A user with email address \"{}\" already exists."
 msgstr "Un utilisateur avec l'adresse email \"{}\" existe déjà."
 
-#: tracim/controllers/admin/user.py:268
+#: tracim/controllers/admin/user.py:283
 msgid "User {} created."
 msgstr "Utilisateur {} créé."
 
-#: tracim/controllers/admin/user.py:307
+#: tracim/controllers/admin/user.py:322
 msgid "User {} updated."
 msgstr "Utilisateur {} mis à jour."
 
-#: tracim/controllers/admin/user.py:321
+#: tracim/controllers/admin/user.py:336
 msgid "User {} activated."
 msgstr "Utilisateur {} activé."
 
-#: tracim/controllers/admin/user.py:332
+#: tracim/controllers/admin/user.py:347
 msgid "You can't de-activate your own account"
 msgstr "Vous ne pouvez pas désactiver votre propre compte"
 
-#: tracim/controllers/admin/user.py:337
+#: tracim/controllers/admin/user.py:352
 msgid "User {} desactivated"
 msgstr "Utilisateur {} désactivé."
 
 msgstr "Vous ne pouvez pas vous retirer de cet espace de travail."
 
 #: tracim/controllers/admin/workspace.py:85
-msgid ""
-"User {} removed. You can <a class=\"alert-link\" href=\"{}\">restore "
-"it</a>"
+msgid "User {} removed. You can <a class=\"alert-link\" href=\"{}\">restore it</a>"
 msgstr "{} archivé(e). <a class=\"alert-link\" href=\"{}\">Annuler l'opération</a>"
 
 #: tracim/controllers/admin/workspace.py:93
 msgstr "Espace de travail {} mis à jour."
 
 #: tracim/controllers/admin/workspace.py:251
-msgid ""
-"{} workspace deleted. In case of error, you can <a class=\"alert-link\" "
-"href=\"{}\">restore it</a>."
-msgstr ""
-"Espace de travail {} supprimé. Vous pouvez <a class=\"alert-link\" "
-"href=\"{}\">annuler l'opération</a>."
+msgid "{} workspace deleted. In case of error, you can <a class=\"alert-link\" href=\"{}\">restore it</a>."
+msgstr "Espace de travail {} supprimé. Vous pouvez <a class=\"alert-link\" href=\"{}\">annuler l'opération</a>."
 
 #: tracim/controllers/admin/workspace.py:264
 msgid "{} workspace restored."
 msgid "%B %d at %I:%M%p"
 msgstr "le %d %B à %H:%M"
 
-#: tracim/lib/helpers.py:71
-msgid "This is the current status."
-msgstr "C'est le statut actuel"
-
-#: tracim/lib/helpers.py:74
-msgid "The item is a normal document, like a howto or a text document."
-msgstr "L'élément est un document normal, comme un howto ou un document texte"
-
-#: tracim/lib/helpers.py:76
-msgid ""
-"The item will be automatically computed as \"in progress\" or \"done\" "
-"according to its children status."
-msgstr ""
-"L'élément sera automatiquement mis en \"En cours\" ou \"Fait\" suivant le"
-" statut de ses enfants."
-
-#: tracim/lib/helpers.py:78
-msgid "No action done on the item."
-msgstr "Aucun changement sur l'élément"
-
-#: tracim/lib/helpers.py:80
-msgid "The item is being worked on."
-msgstr "L'élément est en cours d'utilisation."
-
-#: tracim/lib/helpers.py:82
-msgid "Waiting for some external actions."
-msgstr "En attente d'actions externes."
-
-#: tracim/lib/helpers.py:84
-msgid "The work associated with the item is finished."
-msgstr "L'action associée à l'élément n'est pas terminée."
-
-#: tracim/lib/helpers.py:86
-msgid ""
-"Close the item if you want not to see it anymore. The data won't be "
-"deleted"
-msgstr ""
-"Fermez l'élément si vous ne voulez plus le voir. Les données ne seront "
-"pas supprimées"
-
-#: tracim/lib/helpers.py:88
-msgid "This status tells that the item has been deleted."
-msgstr "Ce status indique que l'élément a été supprimé."
-
 #: tracim/lib/predicates.py:12
 msgid "You are not authorized to access this resource"
 msgstr "Vous n'êtes pas autorisé à accéder à cette ressource"
 
-#: tracim/model/auth.py:131
+#: tracim/model/auth.py:85
 msgid "Nobody"
 msgstr "Personne"
 
-#: tracim/model/auth.py:132 tracim/templates/master_authenticated.mak:86
+#: tracim/model/auth.py:86
+#: tracim/templates/master_authenticated.mak:86
 #: tracim/templates/master_no_toolbar_no_login.mak:111
 #: tracim/templates/user_get_all.mak:13
 msgid "Users"
 msgstr "Utilisateurs"
 
-#: tracim/model/auth.py:133
+#: tracim/model/auth.py:87
 msgid "Global managers"
 msgstr "Managers globaux"
 
-#: tracim/model/auth.py:134
+#: tracim/model/auth.py:88
 msgid "Administrators"
 msgstr "Administrateurs"
 
-#: tracim/model/data.py:88
+#: tracim/model/data.py:79
 msgid "N/A"
 msgstr "N/A"
 
-#: tracim/model/data.py:89
+#: tracim/model/data.py:80
 #: tracim/templates/help/page-user-role-definition.mak:15
 msgid "Reader"
 msgstr "Lecteur"
 
-#: tracim/model/data.py:90
+#: tracim/model/data.py:81
 #: tracim/templates/help/page-user-role-definition.mak:19
 msgid "Contributor"
 msgstr "Contributeurs"
 
-#: tracim/model/data.py:91
+#: tracim/model/data.py:82
 #: tracim/templates/help/page-user-role-definition.mak:23
 msgid "Content Manager"
 msgstr "Gestionnaire de contenu"
 
-#: tracim/model/data.py:92
+#: tracim/model/data.py:83
 #: tracim/templates/help/page-user-role-definition.mak:27
 msgid "Workspace Manager"
 msgstr "Responsable"
 
-#: tracim/model/data.py:162
+#: tracim/model/data.py:153
 msgid "Item archived"
 msgstr "Element archivé"
 
-#: tracim/model/data.py:163
+#: tracim/model/data.py:154
 msgid "Item commented"
 msgstr "Element commenté"
 
-#: tracim/model/data.py:164
+#: tracim/model/data.py:155
 msgid "Item created"
 msgstr "Elément créé"
 
-#: tracim/model/data.py:165
+#: tracim/model/data.py:156
 msgid "Item deleted"
 msgstr "Element supprimé"
 
-#: tracim/model/data.py:166
+#: tracim/model/data.py:157
 msgid "Item modified"
 msgstr "Elément modifié"
 
-#: tracim/model/data.py:167
+#: tracim/model/data.py:158
 msgid "New revision"
 msgstr "Nouvelle version"
 
-#: tracim/model/data.py:168
+#: tracim/model/data.py:159
 msgid "Status modified"
 msgstr "Statut modifié"
 
-#: tracim/model/data.py:169
+#: tracim/model/data.py:160
 msgid "Item un-archived"
 msgstr "Elément désarchivé"
 
-#: tracim/model/data.py:170
+#: tracim/model/data.py:161
 msgid "Item undeleted"
 msgstr "Elément restauré"
 
-#: tracim/model/data.py:207 tracim/model/data.py:217
+#: tracim/model/data.py:198
+#: tracim/model/data.py:208
 msgid "work in progress"
 msgstr "travail en cours"
 
-#: tracim/model/data.py:208 tracim/model/data.py:218
+#: tracim/model/data.py:199
+#: tracim/model/data.py:209
 msgid "closed — validated"
 msgstr "clos(e) — validé(e)"
 
-#: tracim/model/data.py:209 tracim/model/data.py:219
+#: tracim/model/data.py:200
+#: tracim/model/data.py:210
 msgid "closed — cancelled"
 msgstr "clos(e) — annulé(e)"
 
-#: tracim/model/data.py:210 tracim/model/data.py:215 tracim/model/data.py:220
+#: tracim/model/data.py:201
+#: tracim/model/data.py:206
+#: tracim/model/data.py:211
 msgid "deprecated"
 msgstr "obsolète"
 
-#: tracim/model/data.py:212
+#: tracim/model/data.py:203
 msgid "subject in progress"
 msgstr "discussion en cours"
 
-#: tracim/model/data.py:213
+#: tracim/model/data.py:204
 msgid "subject closed — resolved"
 msgstr "discussion close — résolue"
 
-#: tracim/model/data.py:214
+#: tracim/model/data.py:205
 msgid "subject closed — cancelled"
 msgstr "discussion close — annulée"
 
-#: tracim/model/data.py:711
-msgid "Titleless Document"
-msgstr "Document sans titre"
-
 #: tracim/templates/create_account.mak:5
 msgid "Create account"
 msgstr "Créer un compte"
 msgid "Go to my profile"
 msgstr "Consulter mon profil"
 
-#: tracim/templates/error.mak:23 tracim/templates/error_authenticated.mak:20
+#: tracim/templates/error.mak:23
+#: tracim/templates/error_authenticated.mak:20
 msgid "Something went wrong!"
 msgstr "Quelque chose s'est mal passé"
 
 msgid "to contact the support"
 msgstr "de contacter le support"
 
-#: tracim/templates/error.mak:44 tracim/templates/error_authenticated.mak:42
+#: tracim/templates/error.mak:44
+#: tracim/templates/error_authenticated.mak:42
 msgid "The error was: error {code}"
 msgstr "L'erreur était : erreur {code}"
 
 msgid "Move current folder"
 msgstr "Déplacer le dossier courant"
 
-#: tracim/templates/index.mak:25 tracim/templates/index.mak:46
+#: tracim/templates/index.mak:25
+#: tracim/templates/index.mak:46
 #: tracim/templates/master_authenticated.mak:138
 msgid "Login"
 msgstr "Login"
 #: tracim/templates/master_anonymous.mak:67
 #: tracim/templates/master_authenticated.mak:48
 msgid "Create your own email-ready collaborative workspace on trac.im"
-msgstr ""
-"Créez votre propre espace de travail collaboratif compatible avec l'email"
-" sur trac.im"
+msgstr "Créez votre propre espace de travail collaboratif compatible avec l'email sur trac.im"
 
 #: tracim/templates/master_authenticated.mak:80
 #: tracim/templates/master_no_toolbar_no_login.mak:106
 msgid "Create a user account..."
 msgstr "Créer un compte utilisateur"
 
-#: tracim/templates/user_get_all.mak:29 tracim/templates/user_get_all.mak:30
+#: tracim/templates/user_get_all.mak:29
+#: tracim/templates/user_get_all.mak:30
 #: tracim/templates/user_workspace_folder_file_get_one.mak:70
 #: tracim/templates/user_workspace_forms.mak:43
 #: tracim/templates/user_workspace_forms.mak:44
 msgid "Name"
 msgstr "Nom"
 
-#: tracim/templates/user_get_all.mak:33 tracim/templates/user_get_all.mak:93
+#: tracim/templates/user_get_all.mak:33
+#: tracim/templates/user_get_all.mak:93
 #: tracim/templates/user_workspace_forms.mak:227
 #: tracim/templates/workspace_get_one.mak:87
 msgid "Email"
 
 #: tracim/templates/user_get_all.mak:86
 #: tracim/templates/workspace_get_all.mak:58
-msgid ""
-"There are no workspace yet. Start by <a class=\"alert-link\" data-"
-"toggle=\"collapse\" data-target=\"#create-workspace-form\">creating a "
-"workspace</a>."
-msgstr ""
-"Il n'y a pas encore d'espaces de travail. Commencez en <a class=\"alert-"
-"link\" data-toggle=\"collapse\" data-target=\"#create-workspace-"
-"form\">créant un espace de travail</a>."
+msgid "There are no workspace yet. Start by <a class=\"alert-link\" data-toggle=\"collapse\" data-target=\"#create-workspace-form\">creating a workspace</a>."
+msgstr "Il n'y a pas encore d'espaces de travail. Commencez en <a class=\"alert-link\" data-toggle=\"collapse\" data-target=\"#create-workspace-form\">créant un espace de travail</a>."
 
 #: tracim/templates/user_get_all.mak:92
 #: tracim/templates/workspace_get_one.mak:42
 msgid "User disabled. Click to enable this user"
 msgstr "Utilisateur désactivé. Cliquez pour l'activer"
 
-#: tracim/templates/user_get_me.mak:5 tracim/templates/user_get_one.mak:5
+#: tracim/templates/user_get_me.mak:5
+#: tracim/templates/user_get_one.mak:5
 #: tracim/templates/user_profile.mak:5
 msgid "My profile"
 msgstr "Mon profil"
 
-#: tracim/templates/user_get_me.mak:26 tracim/templates/user_get_one.mak:26
+#: tracim/templates/user_get_me.mak:26
+#: tracim/templates/user_get_one.mak:26
 msgid "This user can create workspaces."
 msgstr "Cet utilisateur peut créer des espaces de travail."
 
-#: tracim/templates/user_get_me.mak:29 tracim/templates/user_get_one.mak:29
+#: tracim/templates/user_get_me.mak:29
+#: tracim/templates/user_get_one.mak:29
 msgid "This user is an administrator."
 msgstr "Cet utilisateur est un administrateur"
 
 msgid "My workspaces"
 msgstr "Mes espaces de travail"
 
-#: tracim/templates/user_get_me.mak:42 tracim/templates/user_get_one.mak:42
+#: tracim/templates/user_get_me.mak:42
+#| msgid "This user is not member of any workspace."
+msgid "You are not member of any workspace."
+msgstr "Vous n'êtes membre d'aucun espace de travail"
+
+#: tracim/templates/user_get_one.mak:42
 #: tracim/templates/user_profile.mak:42
 msgid "This user is not member of any workspace."
 msgstr "Cet utilisateur n'est membre d'aucun espace de travail"
 msgstr "Indiquez le contenu du fichier"
 
 #: tracim/templates/user_workspace_folder_file_get_one.mak:33
-msgid ""
-"You are reading <b>an old revision</b> of the current file. (the shown "
-"revision is r{})."
-msgstr ""
-"Vous consultez <b>une ancienne version</b> du fichier courant. (la "
-"version affichée est v{})."
+msgid "You are reading <b>an old revision</b> of the current file. (the shown revision is r{})."
+msgstr "Vous consultez <b>une ancienne version</b> du fichier courant. (la version affichée est v{})."
 
 #: tracim/templates/user_workspace_folder_file_get_one.mak:34
 #: tracim/templates/user_workspace_folder_page_get_one.mak:35
 msgstr "Description"
 
 #: tracim/templates/user_workspace_folder_file_get_one.mak:99
-msgid ""
-"<b>Note</b>: You need to change status in case you want to upload a new "
-"version"
-msgstr ""
-"<b>Note</b>: Vous devez changer le statut du fichier avant de pouvoir "
-"télécharger une nouvelle version"
+msgid "<b>Note</b>: You need to change status in case you want to upload a new version"
+msgstr "<b>Note</b>: Vous devez changer le statut du fichier avant de pouvoir télécharger une nouvelle version"
 
 #: tracim/templates/user_workspace_folder_file_get_one.mak:104
 #: tracim/templates/user_workspace_folder_file_get_one.mak:108
 msgstr "Rédigez le contenu de la page"
 
 #: tracim/templates/user_workspace_folder_page_get_one.mak:34
-msgid ""
-"You are reading <b>an old revision</b> of the current page. (the shown "
-"revision is r{})."
-msgstr ""
-"Vous consultez <b>une ancienne version</b> de al page courante. (la "
-"version affichée est la v{})."
+msgid "You are reading <b>an old revision</b> of the current page. (the shown revision is r{})."
+msgstr "Vous consultez <b>une ancienne version</b> de al page courante. (la version affichée est la v{})."
 
 #: tracim/templates/user_workspace_folder_page_get_one.mak:65
 msgid "Links extracted from the page"
 msgstr "Vous pouvez décrire le sujet (facultatif)"
 
 #: tracim/templates/user_workspace_folder_thread_get_one.mak:64
-msgid ""
-"<b>Note</b>: In case you'd like to post a reply, you must first open "
-"again the thread"
-msgstr ""
-"<b>Note</b> : si vous souhaitez commenter cette discussion, vous devez "
-"tout d'abord en modifier le statut pour la ré-ouvrir"
+msgid "<b>Note</b>: In case you'd like to post a reply, you must first open again the thread"
+msgstr "<b>Note</b> : si vous souhaitez commenter cette discussion, vous devez tout d'abord en modifier le statut pour la ré-ouvrir"
 
 #: tracim/templates/user_workspace_folder_thread_get_one.mak:69
 msgid "Post a reply..."
 msgstr "Rôle"
 
 #: tracim/templates/workspace_get_one.mak:80
-msgid ""
-"There are no user associated to the current workspace. Start by <a class"
-"=\"alert-link\" data-toggle=\"collapse\" data-target=\"#add-role-from-"
-"existing-user-form\">adding members</a>  to the workspace."
-msgstr ""
-"Il n'y a aucun membre dans cet espace de travail. Commencez par <a class"
-"=\"alert-link\" data-toggle=\"collapse\" data-target=\"#add-role-from-"
-"existing-user-form\">ajouter des membres</a> à cet espace."
+msgid "There are no user associated to the current workspace. Start by <a class=\"alert-link\" data-toggle=\"collapse\" data-target=\"#add-role-from-existing-user-form\">adding members</a>  to the workspace."
+msgstr "Il n'y a aucun membre dans cet espace de travail. Commencez par <a class=\"alert-link\" data-toggle=\"collapse\" data-target=\"#add-role-from-existing-user-form\">ajouter des membres</a> à cet espace."
 
 #: tracim/templates/workspace_get_one.mak:107
 msgid "Change role to..."
 
 #: tracim/templates/help/page-user-role-definition.mak:11
 msgid "Roles give progressive rights on what the user can or can't do."
-msgstr ""
-"Les rôles donnent des droits progressifs qui déterminent ce que "
-"l'utilisateur peut ou ne peut pas faire."
+msgstr "Les rôles donnent des droits progressifs qui déterminent ce que l'utilisateur peut ou ne peut pas faire."
 
 #: tracim/templates/help/page-user-role-definition.mak:16
 msgid "This role gives read-only access to workspace resources."
 msgstr "Ce rôle donne accès en lecteur aux informations de l'espace de travail."
 
 #: tracim/templates/help/page-user-role-definition.mak:20
-msgid ""
-"Same as <span style=\"color: #1fdb11;\">reader</span> + contribution "
-"rights: edit, comments, status update."
-msgstr ""
-"Comme <span style=\"color: #1fdb11;\">lecteur</span> + contribution : "
-"modifications, commentaires, mise à jour du statut."
+msgid "Same as <span style=\"color: #1fdb11;\">reader</span> + contribution rights: edit, comments, status update."
+msgstr "Comme <span style=\"color: #1fdb11;\">lecteur</span> + contribution : modifications, commentaires, mise à jour du statut."
 
 #: tracim/templates/help/page-user-role-definition.mak:24
-msgid ""
-"Same as <span style=\"color: #759ac5;\">contributor</span> + content "
-"management rights: move content, folders management, delete archive "
-"operations."
-msgstr ""
-"Comme <span style=\"color: #759ac5;\">contributeur</span> + gestion du "
-"contenu : déplacer le contenu, les dossiers"
+msgid "Same as <span style=\"color: #759ac5;\">contributor</span> + content management rights: move content, folders management, delete archive operations."
+msgstr "Comme <span style=\"color: #759ac5;\">contributeur</span> + gestion du contenu : déplacer le contenu, les dossiers"
 
 #: tracim/templates/help/page-user-role-definition.mak:28
-msgid ""
-"Same as <span style=\"color: #ea983d;\">content manager</span> + "
-"workspace management rights: edit workspace, invite users, revoke them."
-msgstr ""
-"Comme <span style=\"color: #ea983d;\">gestionnaire de contenu</span> + "
-"modification de l'espace de travail."
+msgid "Same as <span style=\"color: #ea983d;\">content manager</span> + workspace management rights: edit workspace, invite users, revoke them."
+msgstr "Comme <span style=\"color: #ea983d;\">gestionnaire de contenu</span> + modification de l'espace de travail."
 
 #~ msgid "You have no document yet."
 #~ msgstr "Vous n'avez pas de document pour le moment."
 #~ msgid "page"
 #~ msgstr "page"
 
+#~ msgid "This is the current status."
+#~ msgstr "C'est le statut actuel"
+
+#~ msgid "The item is a normal document, like a howto or a text document."
+#~ msgstr "L'élément est un document normal, comme un howto ou un document texte"
+
+#~ msgid ""
+#~ "The item will be automatically computed"
+#~ " as \"in progress\" or \"done\" "
+#~ "according to its children status."
+#~ msgstr ""
+#~ "L'élément sera automatiquement mis en "
+#~ "\"En cours\" ou \"Fait\" suivant le "
+#~ "statut de ses enfants."
+
+#~ msgid "No action done on the item."
+#~ msgstr "Aucun changement sur l'élément"
+
+#~ msgid "The item is being worked on."
+#~ msgstr "L'élément est en cours d'utilisation."
+
+#~ msgid "Waiting for some external actions."
+#~ msgstr "En attente d'actions externes."
+
+#~ msgid "The work associated with the item is finished."
+#~ msgstr "L'action associée à l'élément n'est pas terminée."
+
+#~ msgid ""
+#~ "Close the item if you want not "
+#~ "to see it anymore. The data won't"
+#~ " be deleted"
+#~ msgstr ""
+#~ "Fermez l'élément si vous ne voulez "
+#~ "plus le voir. Les données ne "
+#~ "seront pas supprimées"
+
+#~ msgid "This status tells that the item has been deleted."
+#~ msgstr "Ce status indique que l'élément a été supprimé."
+
+#~ msgid "Titleless Document"
+#~ msgstr "Document sans titre"

tracim/tracim/lib/__init__.py

 # -*- coding: utf-8 -*-
 from tg.i18n import lazy_ugettext as l_
 
+class NotFoundError(Exception):
+    pass
+
 class CST(object):
     STATUS_ERROR = 'error'
     STATUS_OK = 'ok'

tracim/tracim/lib/auth.py

-# -*- coding: utf-8 -*-
-"""Predicates for authorizations"""
-from tg.predicates import Predicate
-from tracim.model import DBSession as session
-from tracim.model.auth import Permission, User
-import logging as l
-
-DIRTY_canReadOrCanWriteSqlQuery = """
-SELECT
-    pgn.node_id
-FROM
-    pod_group_node AS pgn
-    JOIN pod_nodes AS pn ON pn.node_id = pgn.node_id AND pn.is_shared = 't'
-    JOIN pod_user_group AS pug ON pug.group_id = pgn.group_id
-    JOIN pod_user AS pu ON pug.user_id = pu.user_id
-WHERE
-    rights > :excluded_right_low_level
-    AND email_address = :email
-    AND pgn.node_id = :node_id
-UNION
-    SELECT
-        pnn.node_id
-    FROM
-        pod_nodes AS pnn,
-        pod_user AS puu
-    WHERE
-        pnn.node_id = :node_id
-        AND pnn.owner_id = puu.user_id
-        AND puu.email_address = :email
-"""
-
-class can_read(Predicate):
-    message = ""
-
-    def __init__(self, **kwargs):
-        pass
-
-    def evaluate(self, environ, credentials):
-        if 'node_id' in environ['webob.adhoc_attrs']['validation']['values']:
-            node_id = environ['webob.adhoc_attrs']['validation']['values']['node_id']
-            if node_id!=0:
-                has_right = session.execute(
-                    DIRTY_canReadOrCanWriteSqlQuery,
-                    {"email":credentials["repoze.who.userid"], "node_id":node_id, "excluded_right_low_level": 0}
-                )
-                if has_right.rowcount == 0 :
-                    l.info("User {} don't have read right on node {}".format(credentials["repoze.who.userid"], node_id))
-                    self.unmet()
-
-class can_write(Predicate):
-    message = ""
-
-    def __init__(self, **kwargs):
-        pass
-
-    def evaluate(self, environ, credentials):
-        node_id = environ['webob.adhoc_attrs']['validation']['values']['node_id']
-        if node_id!=0:
-            has_right = session.execute(
-                DIRTY_canReadOrCanWriteSqlQuery,
-                {"email":credentials["repoze.who.userid"], "node_id":node_id, "excluded_right_low_level": 1}
-            )
-            if has_right.rowcount == 0 :
-                self.unmet()
-

tracim/tracim/lib/base.py

         :param id:
         :return:
         """
-        print('***********************************')
-        print("searching for an id")
-        print(cls)
-        print(cls)
         return getattr(tmpl_context, cls.current_item_id_key_in_context(), '')
 
     def back_with_error(self, message):

tracim/tracim/lib/content.py

 from tracim.model import DBSession
 from tracim.model.auth import User
 from tracim.model.data import ContentStatus, ContentRevisionRO, ActionDescription
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import Workspace
 
 class ContentApi(object):
         self._show_deleted = show_deleted
 
     def _base_query(self, workspace: Workspace=None):
-        result = DBSession.query(PBNode)
+        result = DBSession.query(Content)
         if workspace:
-            result = result.filter(PBNode.workspace_id==workspace.workspace_id)
+            result = result.filter(Content.workspace_id==workspace.workspace_id)
 
         if not self._show_deleted:
-            result = result.filter(PBNode.is_deleted==False)
+            result = result.filter(Content.is_deleted==False)
 
         if not self._show_archived:
-            result = result.filter(PBNode.is_archived==False)
+            result = result.filter(Content.is_archived==False)
 
         return result
 
-    def get_child_folders(self, parent: PBNode=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[]) -> [PBNode]:
-        # assert parent is None or isinstance(parent, PBNode) # DYN_REMOVE
-        # assert workspace is None or isinstance(workspace, Workspace) # DYN_REMOVE
+    def get_child_folders(self, parent: Content=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[]) -> [Content]:
 
-        parent_id = parent.node_id if parent else None
+        parent_id = parent.content_id if parent else None
         folders = self._base_query(workspace).\
-            filter(PBNode.parent_id==parent_id).\
-            filter(PBNode.node_type==PBNodeType.Folder).\
-            filter(PBNode.node_id.notin_(removed_item_ids)).\
+            filter(Content.parent_id==parent_id).\
+            filter(Content.type==ContentType.Folder).\
+            filter(Content.content_id.notin_(removed_item_ids)).\
             all()
 
         if not filter_by_allowed_content_types or len(filter_by_allowed_content_types)<=0:
         result = []
         for folder in folders:
             for allowed_content_type in filter_by_allowed_content_types:
-                print('ALLOWED = ', filter_by_allowed_content_types)
-                print('CONTENT = ', folder.properties['allowed_content'])
-                # exit()
                 if folder.properties['allowed_content'][allowed_content_type]==True:
                     result.append(folder)
 
         return result
 
-    def create(self, content_type: str, workspace: Workspace=None, parent: PBNode=None, label:str ='', do_save=False) -> PBNode:
-        assert content_type in PBNodeType.allowed_types()
-        content = PBNode()
+    def create(self, content_type: str, workspace: Workspace=None, parent: Content=None, label:str ='', do_save=False) -> Content:
+        assert content_type in ContentType.allowed_types()
+        content = Content()
         content.owner = self._user
         content.parent = parent
         content.workspace = workspace
-        content.node_type = content_type
-        content.data_label = label
-        content.last_action = ActionDescription.CREATION
+        content.type = content_type
+        content.label = label
+        content.revision_type = ActionDescription.CREATION
 
         if do_save:
             self.save(content)
         return content
 
 
-    def create_comment(self, workspace: Workspace=None, parent: PBNode=None, content:str ='', do_save=False) -> PBNode:
-        assert parent  and parent.node_type!=PBNodeType.Folder
-        item = PBNode()
+    def create_comment(self, workspace: Workspace=None, parent: Content=None, content:str ='', do_save=False) -> Content:
+        assert parent  and parent.type!=ContentType.Folder
+        item = Content()
         item.owner = self._user
         item.parent = parent
         item.workspace = workspace
-        item.node_type = PBNodeType.Comment
-        item.data_content = content
-        item.data_label = ''
-        item.last_action = ActionDescription.COMMENT
+        item.type = ContentType.Comment
+        item.description = content
+        item.label = ''
+        item.revision_type = ActionDescription.COMMENT
 
         if do_save:
             self.save(item)
         return content
 
 
-    def get_one_from_revision(self, content_id: int, content_type: str, workspace: Workspace=None, revision_id=None) -> PBNode:
+    def get_one_from_revision(self, content_id: int, content_type: str, workspace: Workspace=None, revision_id=None) -> Content:
         """
         This method is a hack to convert a node revision item into a node
         :param content_id:
         """
 
         content = self.get_one(content_id, content_type, workspace)
-        revision = DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.version_id==revision_id).one()
+        revision = DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.revision_id==revision_id).one()
 
-        if revision.node_id==content.node_id:
-            content.revision_to_serialize = revision.version_id
+        if revision.content_id==content.content_id:
+            content.revision_to_serialize = revision.revision_id
         else:
             raise ValueError('Revision not found for given content')
 
         return content
 
-    def get_one(self, content_id: int, content_type: str, workspace: Workspace=None) -> PBNode:
+    def get_one(self, content_id: int, content_type: str, workspace: Workspace=None) -> Content:
         assert content_id is None or isinstance(content_id, int) # DYN_REMOVE
         assert content_type is not None # DYN_REMOVE
         assert isinstance(content_type, str) # DYN_REMOVE
         if not content_id:
             return
 
-        if content_type==PBNodeType.Any:
+        if content_type==ContentType.Any:
             return self._base_query(workspace).\
-                filter(PBNode.node_id==content_id).\
+                filter(Content.content_id==content_id).\
                 one()
 
         return self._base_query(workspace).\
-            filter(PBNode.node_id==content_id).\
-            filter(PBNode.node_type==content_type).\
+            filter(Content.content_id==content_id).\
+            filter(Content.type==content_type).\
             one()
 
-    def get_all(self, parent_id: int, content_type: str, workspace: Workspace=None) -> PBNode:
+    def get_all(self, parent_id: int, content_type: str, workspace: Workspace=None) -> Content:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
         assert content_type is not None # DYN_REMOVE
         assert isinstance(content_type, str) # DYN_REMOVE
             return
 
         return self._base_query(workspace).\
-            filter(PBNode.parent_id==parent_id).\
-            filter(PBNode.node_type==content_type).\
+            filter(Content.parent_id==parent_id).\
+            filter(Content.type==content_type).\
             all()
 
-    def set_allowed_content(self, folder: PBNode, allowed_content_dict:dict):
+    def set_allowed_content(self, folder: Content, allowed_content_dict:dict):
         """
         :param folder: the given folder instance
         :param allowed_content_dict: must be something like this:
             )
         :return:
         """
-        assert folder.node_type==PBNodeType.Folder
+        assert folder.type==ContentType.Folder
         assert 'file' in allowed_content_dict.keys()
         assert 'folder' in allowed_content_dict.keys()
         assert 'page' in allowed_content_dict.keys()
         folder.properties = properties
 
 
-    def set_status(self, content: PBNode, new_status: str):
+    def set_status(self, content: Content, new_status: str):
         if new_status in ContentStatus.allowed_values():
-            content.node_status = new_status
-            content.last_action = ActionDescription.STATUS_UPDATE
+            content.status = new_status
+            content.revision_type = ActionDescription.STATUS_UPDATE
         else:
             raise ValueError('The given value {} is not allowed'.format(new_status))
 
 
-    def move(self, item: PBNode, new_parent: PBNode, must_stay_in_same_workspace:bool=True):
+    def move(self, item: Content, new_parent: Content, must_stay_in_same_workspace:bool=True):
         if must_stay_in_same_workspace:
             if new_parent and new_parent.workspace_id!=item.workspace_id:
                 raise ValueError('the item should stay in the same workspace')
 
         item.parent = new_parent
-        item.last_action = ActionDescription.EDITION
+        item.revision_type = ActionDescription.EDITION
 
 
-    def update_content(self, item: PBNode, new_label: str, new_content: str) -> PBNode:
-        item.data_label = new_label
-        item.data_content = new_content # TODO: convert urls into links
-        item.last_action = ActionDescription.EDITION
+    def update_content(self, item: Content, new_label: str, new_content: str) -> Content:
+        item.label = new_label
+        item.description = new_content # TODO: convert urls into links
+        item.revision_type = ActionDescription.EDITION
         return item
 
-    def update_file_data(self, item: PBNode, new_filename: str, new_mimetype: str, new_file_content) -> PBNode:
-        item.data_file_name = new_filename
-        item.data_file_mime_type = new_mimetype
-        item.data_file_content = new_file_content
+    def update_file_data(self, item: Content, new_filename: str, new_mimetype: str, new_file_content) -> Content:
+        item.file_name = new_filename
+        item.file_mimetype = new_mimetype
+        item.file_content = new_file_content
         return item
 
-    def archive(self, content: PBNode):
+    def archive(self, content: Content):
         content.is_archived = True
-        content.last_action = ActionDescription.ARCHIVING
+        content.revision_type = ActionDescription.ARCHIVING
 
-    def unarchive(self, content: PBNode):
+    def unarchive(self, content: Content):
         content.is_archived = False
-        content.last_action = ActionDescription.UNARCHIVING
+        content.revision_type = ActionDescription.UNARCHIVING
 
 
-    def delete(self, content: PBNode):
+    def delete(self, content: Content):
         content.is_deleted = True
-        content.last_action = ActionDescription.DELETION
+        content.revision_type = ActionDescription.DELETION
 
-    def undelete(self, content: PBNode):
+    def undelete(self, content: Content):
         content.is_deleted = False
-        content.last_action = ActionDescription.UNDELETION
+        content.revision_type = ActionDescription.UNDELETION
 
-    def save(self, content: PBNode, action_description: str=None, do_flush=True):
+    def save(self, content: Content, action_description: str=None, do_flush=True):
         """
-        Save an object, flush the session and set the last_action property
+        Save an object, flush the session and set the revision_type property
         :param content:
         :param action_description:
         :return:
 
         if not action_description:
             # See if the last action has been modified
-            if content.last_action==None or len(get_history(content, 'last_action'))<=0:
+            if content.revision_type==None or len(get_history(content, 'revision_type'))<=0:
                 # The action has not been modified, so we set it to default edition
                 action_description = ActionDescription.EDITION
 
-        content.last_action = action_description
+        content.revision_type = action_description
 
         if do_flush:
             DBSession.flush()

tracim/tracim/lib/dbapi.py

-# -*- coding: utf-8 -*-
-"""
-"""
-import os
-from datetime import datetime
-from hashlib import sha256
-
-from sqlalchemy import Table, ForeignKey, Column
-from sqlalchemy.types import Unicode, Integer, DateTime, Text
-from sqlalchemy.orm import relation, synonym
-from sqlalchemy.orm import joinedload_all
-import sqlalchemy.orm as sqlao
-import sqlalchemy as sqla
-
-from tracim.model import data as pbmd
-from tracim.model import auth as pbma
-import tracim.model as pbm
-
-from tracim.model.auth import User, Group
-
-import tg
-
-FIXME_ERROR_CODE=-1
-
-class PODUserFilteredApiController(object):
-  
-  def __init__(self, piUserId, piExtraUserIdList=[]):
-    self._iCurrentUserId       = piUserId
-    self._iExtraUserIdList     = piExtraUserIdList
-    self._iUserIdFilteringList = None
-    self._cache_allowed_nodes = None
-
-  def _getUserIdListForFiltering(self):
-    if self._iUserIdFilteringList==None:
-      self._iUserIdFilteringList = list()
-      self._iUserIdFilteringList.append(self._iCurrentUserId)
-      for liUserId in self._iExtraUserIdList:
-        self._iUserIdFilteringList.append(liUserId)
-    return self._iUserIdFilteringList
-
-
-  def createNode(self, parent_id=0, inherit_rights=True):
-    loNode          = pbmd.PBNode()
-    loNode.owner_id = self._iCurrentUserId
-    if int(parent_id)!=0:
-        loNode.parent_id = parent_id
-
-    if inherit_rights:
-        parent_node = pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.node_id==parent_id).one()
-        self.copy_rights(parent_node, loNode)
-
-    pbm.DBSession.add(loNode)
-
-    return loNode
-
-  def copy_rights(self, from_node: pbmd.PBNode, to_node: pbmd.PBNode, copy_also_is_shared=True):
-    """
-    copy rights from first node to second one
-    """
-    for parent_right in from_node._lRights:
-        new_right = self.createRight()
-        new_right.group_id = parent_right.group_id
-        new_right.rights = parent_right.rights
-        to_node._lRights.append(new_right)
-
-    if copy_also_is_shared:
-        to_node.is_shared = from_node.is_shared
-
-  def createDummyNode(self, parent_id, inherit_rights=True):
-    loNewNode = self.createNode(parent_id, inherit_rights)
-    loNewNode.data_label   = ''
-    loNewNode.data_content = ''
-    return loNewNode
-
-
-  def getNode(self, liNodeId: int) -> pbmd.PBNode:
-
-    lsSqlSelectQuery = """pod_nodes.node_id IN
-        (SELECT
-            pgn.node_id
-        FROM
-            pod_group_node AS pgn
-            join pod_user_group AS pug ON pug.group_id = pgn.group_id
-            join pod_user AS pu ON pug.user_id = pu.user_id
-        WHERE
-            rights > 0
-            AND pu.user_id = %s)
-    """
-    lsNodeIdFiltering = lsSqlSelectQuery % (str(self._iCurrentUserId))
-
-    if liNodeId!=None and liNodeId!=0:
-      return pbm.DBSession.query(pbmd.PBNode).options(sqlao.joinedload_all("_oParent"), sqlao.joinedload_all("_lAllChildren"))\
-        .filter(pbmd.PBNode.node_id==liNodeId)\
-        .filter(
-          sqla.or_(
-            pbmd.PBNode.owner_id==self._iCurrentUserId,
-            lsNodeIdFiltering
-          )
-        )\
-        .one()
-    return None
-
-  def getLastModifiedNodes(self, piMaxNodeNb: int):
-    """
-    Returns a list of nodes order by modification time and limited to piMaxNodeNb nodes
-    """
-    liOwnerIdList = self._getUserIdListForFiltering()
-    return pbm.DBSession.query(pbmd.PBNode)\
-        .outerjoin(pbma.Rights)\
-        .outerjoin(pbma.user_group_table, pbma.Rights.group_id==pbma.user_group_table.columns['group_id'])\
-        .options(joinedload_all("_lAllChildren"))\
-        .filter((pbmd.PBNode.owner_id.in_(liOwnerIdList)) | ((pbma.user_group_table.c.user_id.in_(liOwnerIdList)) & (pbmd.PBNode.is_shared == True)))\
-        .order_by(pbmd.PBNode.updated_at.desc())\
-        .limit(piMaxNodeNb).all()
-
-
-  def getListOfAllowedNodes(self, reset_cache=False) -> pbmd.PBNode:
-      if self._cache_allowed_nodes==None or reset_cache==True:
-        lsSqlQuery = """
-            SELECT
-                pn.node_id,
-                pn.parent_id,
-                pn.node_order,
-                pn.node_type,
-                pn.created_at,
-                pn.updated_at,
-                pn.data_label,
-                pn.data_content,
-                pn.data_datetime,
-                pn.node_status,
-                pn.data_reminder_datetime,
-                pn.parent_tree_path,
-                pn.node_depth,
-                pn.owner_id,
-                pn.is_shared,
-                pn.is_public,
-                pn.public_url_key
-            FROM
-                pod_group_node AS pgn
-                join pod_user_group AS pug ON pug.group_id = pgn.group_id
-                join pod_nodes AS pn ON pgn.node_id=pn.node_id AND pn.is_shared='t'
-            WHERE
-                pn.node_type='data'
-                AND pn.node_status NOT IN ('deleted', 'closed')
-                AND pn.node_id=pgn.node_id
-                AND pgn.rights > 0
-                AND pug.user_id = :owner_id
-
-            UNION
-                SELECT
-                    pn.node_id,
-                    pn.parent_id,
-                    pn.node_order,
-                    pn.node_type,
-                    pn.created_at,
-                    pn.updated_at,
-                    pn.data_label,
-                    pn.data_content,
-                    pn.data_datetime,
-                    pn.node_status,
-                    pn.data_reminder_datetime,
-                    pn.parent_tree_path,
-                    pn.node_depth,
-                    pn.owner_id,
-                    pn.is_shared,
-                    pn.is_public,
-                    pn.public_url_key
-                FROM
-                    pod_nodes AS pn
-                WHERE
-                    pn.node_type = 'data'
-                    AND pn.node_status NOT IN ('deleted', 'closed')
-                    AND pn.owner_id = :owner_id
-
-            ORDER BY node_id ASC
-        """
-
-        loNodeListResult = pbm.DBSession.query(pbmd.PBNode).\
-            from_statement(lsSqlQuery).\
-            params(owner_id=self._iCurrentUserId)
-        allowed_nodes = loNodeListResult.all()
-
-        self._cache_allowed_nodes = allowed_nodes
-
-      return self._cache_allowed_nodes
-
-
-  def searchNodesByText(self, plKeywordList: [str], piMaxNodeNb=100):
-    """
-    Returns a list of nodes order by type, nodes which contain at least one of the keywords
-    """
-    liOwnerIdList = self._getUserIdListForFiltering()
-    loKeywordFilteringClauses = []
-    for keyword in plKeywordList:
-        loKeywordFilteringClauses.append(pbmd.PBNode.data_label.ilike('%'+keyword+'%'))
-        loKeywordFilteringClauses.append(pbmd.PBNode.data_content.ilike('%'+keyword+'%'))
-        loKeywordFilteringClauses.append(pbmd.PBNode.data_file_name.ilike('%'+keyword+'%'))
-
-    loKeywordFilteringClausesAsOr = sqla.or_(*loKeywordFilteringClauses) # Combine them with or to a BooleanClauseList
-
-    loResultsForSomeKeywords = pbm.DBSession.query(pbmd.PBNode).options(joinedload_all("_lAllChildren")).outerjoin(pbma.Rights).outerjoin(pbma.user_group_table, pbma.Rights.group_id==pbma.user_group_table.columns['group_id'])\
-        .filter(loKeywordFilteringClausesAsOr)\
-        .filter((pbmd.PBNode.owner_id.in_(liOwnerIdList)) | (pbma.user_group_table.c.user_id.in_(liOwnerIdList) & pbmd.PBNode.is_shared))\
-        .order_by(sqla.desc(pbmd.PBNode.node_type))\
-        .limit(piMaxNodeNb)\
-        .all()
-
-    return loResultsForSomeKeywords
-
-  def getNodesByStatus(self, psNodeStatus, piMaxNodeNb=5):
-    liOwnerIdList = self._getUserIdListForFiltering()
-    return pbm.DBSession.query(pbmd.PBNode).options(joinedload_all("_lAllChildren")).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.node_status==psNodeStatus).order_by(pbmd.PBNode.updated_at).limit(piMaxNodeNb).all()
-
-
-  def getChildNodesForMenu(self, poParentNode: pbmd.PBNode, allowed_nodes: [pbmd.PBNode]) -> [pbmd.PBNode]:
-    visible_child_nodes = []
-
-    if poParentNode!=None:
-        # standard case
-        print(" -------------- BEFORE @@@@@@@@@@@@@@@@ ")
-        all_child_nodes = poParentNode.getChildren()
-        print("@@@@@@@@@@@@@@@@ AFTER @@@@@@@@@@@@@@@@ ")
-        for child_node in all_child_nodes:
-          if child_node in allowed_nodes:
-            visible_child_nodes.append(child_node)
-    else:
-        # Root case
-        parent_nodes = pbm.DBSession
-        for allowed_node in allowed_nodes:
-            print("     @@@@@@@@@@@@@@@@ BEFORE @@@@@@@@@@@@@@@@ ")
-            # loParent = allowed_node._oParent
-            # print("@@@@@@@@@@@@@@@@ AFTER @@@@@@@@@@@@@@@@ {0}".format(allowed_node._oParent.node_id if allowed_node._oParent!=None else '0'))
-            # print("==== EXTRA {0}".format(allowed_node._oParent.node_id if allowed_node._oParent!=None else '0'))
-            print("====> ")
-
-            if allowed_node._oParent is None or allowed_node._oParent==allowed_node:
-                # D.A. - HACK - 2014-05-27
-                # I don't know why, but as from now (with use of sqlao.contains_eager in getListOfAllowedNodes()
-                # the root items have at first iteration itself as parent
-                print("==== EXTRA END")
-                # this is a root item => add it
-                visible_child_nodes.append(allowed_node)
-            else:
-                if allowed_node._oParent not in allowed_nodes:
-                    # the node is visible but not the parent => put it at the root
-                    visible_child_nodes.append(allowed_node)
-                else:
-                    print("==== EXTRA END 2 {0}".format(allowed_node._oParent.node_id))
-
-    print(" @@@@@@@@@@@@@@@@ PRE FAILURE @@@@@@@@@@@@@@@@ ")
-    return visible_child_nodes
-
-
-
-
-  def buildTreeListForMenu(self, current_node: pbmd.PBNode, allowed_nodes: [pbmd.PBNode]) -> [pbmd.NodeTreeItem]:
-    # The algorithm is:
-    # 1. build an intermediate tree containing only current node and parent path
-    #    + complete it with sibling at each level (except root)
-    # 2. add sibling nodes at root level
-    # 3. complete it with shared documents (which are not at root but shared with current user)
-
-    node_tree = []
-
-    previous_tree_item = None
-    tmp_children_nodes = []
-
-    if current_node is not None:
-        breadcrumb_nodes = current_node.getBreadCrumbNodes()
-        breadcrumb_nodes.append(current_node) # by default the current node is not included
-
-        for breadcrumb_node in reversed(breadcrumb_nodes):
-            if previous_tree_item is None:
-                # First iteration. We add all current_node children
-                for child_node in breadcrumb_node.getChildren():
-                    if child_node in allowed_nodes:
-                        child_item = pbmd.NodeTreeItem(child_node, [])
-                        tmp_children_nodes.append(child_item)
-
-                previous_tree_item = pbmd.NodeTreeItem(breadcrumb_node, tmp_children_nodes)
-
-            else:
-                tmp_children_nodes = []
-                for child_node in breadcrumb_node.getChildren():
-                    if child_node in allowed_nodes:
-                        if child_node == previous_tree_item.node:
-                            tmp_children_nodes.append(previous_tree_item)
-                        else:
-                            sibling_node = pbmd.NodeTreeItem(child_node, [])
-                            tmp_children_nodes.append(sibling_node)
-
-                previous_tree_item = pbmd.NodeTreeItem(breadcrumb_node, tmp_children_nodes)
-
-    for node in allowed_nodes:
-        # This part of the algorithm insert root items
-        if node.parent_id==0 or node.parent_id is None:
-            if previous_tree_item is not None and node == previous_tree_item.node:
-                assert(isinstance(previous_tree_item, pbmd.NodeTreeItem))
-                node_tree.append(previous_tree_item)
-            else:
-                node_tree.append(pbmd.NodeTreeItem(node, []))
-        else:
-            # Try to add nodes shared with me but with a parent which is not shared
-            if node.owner_id!=self._iCurrentUserId:
-                # this is a node shared with me
-                if node._oParent!=None and node._oParent not in allowed_nodes:
-                    # the node is shared but not the parent => put it in the root
-                    node_tree.append(pbmd.NodeTreeItem(node, []))
-
-
-    return node_tree
-
-
-
-  def DIRTY_OLDbuildTreeListForMenu(self, plViewableStatusId: []) -> [pbmd.PBNode]:
-
-    liOwnerIdList = self._getUserIdListForFiltering()
-    
-    # loNodeList = pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.node_type==pbmd.PBNodeType.Data).filter(pbmd.PBNode.node_status.in_(plViewableStatusId)).order_by(pbmd.PBNode.parent_tree_path).order_by(pbmd.PBNode.node_order).order_by(pbmd.PBNode.node_id).all()
-    loNodeListNotFiltered = pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.node_type==pbmd.PBNodeType.Data).filter(pbmd.PBNode.node_status.in_(plViewableStatusId)).order_by(pbmd.PBNode.parent_tree_path).order_by(pbmd.PBNode.node_order).order_by(pbmd.PBNode.node_id).all()
-
-    loNodeList = []
-    for loNode in loNodeListNotFiltered:
-      if loNode.owner_id in self._getUserIdListForFiltering():
-        loNodeList.append(loNode)
-      else:
-        for loRight in loNode._lRights:
-          for loUser in loRight._oGroup.users:
-            if loUser.user_id in self._getUserIdListForFiltering():
-              loNodeList.append(loNode)
-
-    loTreeList = []
-    loTmpDict = {}
-    for loNode in loNodeList:
-      loTmpDict[loNode.node_id] = loNode
-  
-      if loNode.parent_id==None or loNode.parent_id==0:
-        loTreeList.append(loNode)
-      else:
-        # append the node to the parent list
-        # FIXME - D.A - 2013-10-08
-        # The following line may raise an exception
-        # We suppose that the parent node has already been added
-        # this *should* be the case, but the code does not check it
-        if loNode.parent_id not in loTmpDict.keys():
-          try:
-
-            loTmpDict[loNode.parent_id] = self.getNode(loNode.parent_id)
-          except Exception as e:
-            # loTreeList.append(
-            # FIXME - D.A. - 2014-05-22 This may be wrong code:
-            # we are in the case when the node parent is not shared with the current user
-            # So the node should be added at the root
-            pass
-        if loNode.parent_id in loTmpDict.keys():
-          # HACK- D.A. - 2014-05-22 - See FIXME upper
-          loTmpDict[loNode.parent_id].appendStaticChild(loNode)
-  
-    return loTreeList
-
-  def getParentNode(self, loNode):
-    liOwnerIdList = self._getUserIdListForFiltering()
-    return pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.node_id==loNode.parent_id).one()
-
-  def getSiblingNodes(self, poNode, pbReverseOrder=False):
-    liOwnerIdList = self._getUserIdListForFiltering()
-    
-    if pbReverseOrder:
-      return pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.parent_id==poNode.parent_id).order_by(pbmd.PBNode.node_order.desc()).all()
-    else:
-      return pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.parent_id==poNode.parent_id).order_by(pbmd.PBNode.node_order).all()
-
-  def resetNodeOrderOfSiblingNodes(self, loSiblingNodes):
-    liNewWeight = 0
-    for loNode in loSiblingNodes:
-      liNewWeight = liNewWeight + 1
-      loNode.node_order = liNewWeight
-    # DBSession.save()
-
-  def moveNodeUpper(self, loNode):
-    # FIXME - manage errors and logging
-    
-    loSiblingNodes = self.getSiblingNodes(loNode)
-    self.resetNodeOrderOfSiblingNodes(loSiblingNodes)
-  
-    loPreviousItem = None
-    for loItem in loSiblingNodes:
-      if loItem==loNode:
-        if loPreviousItem==None:
-          return FIXME_ERROR_CODE # FIXME - D.A. Do not use hard-coded error codes
-          print("No previous node")
-        else:
-          liPreviousItemOrder       = loPreviousItem.node_order
-          loPreviousItem.node_order = loNode.node_order
-          loNode.node_order         = liPreviousItemOrder
-          # DBSession.save()
-          break
-      loPreviousItem = loItem
-
-  def moveNodeLower(self, loNode):
-    # FIXME - manage errors and logging
-    
-    loSiblingNodes = self.getSiblingNodes(loNode)
-    self.resetNodeOrderOfSiblingNodes(loSiblingNodes)
-  
-    loPreviousItem = None
-    for loItem in reversed(loSiblingNodes):
-      if loItem==loNode:
-        if loPreviousItem==None:
-          return FIXME_ERROR_CODE # FIXME - D.A. Do not use hard-coded error codes
-          # FIXME
-          print("No previous node")
-        else:
-          liPreviousItemOrder       = loPreviousItem.node_order
-          loPreviousItem.node_order = loNode.node_order
-          loNode.node_order         = liPreviousItemOrder
-          # DBSession.save()
-          break
-      loPreviousItem = loItem
-
-  def getNodeFileContent(self, liNodeId):
-    liOwnerIdList = self._getUserIdListForFiltering()
-    return pbm.DBSession.query(pbmd.PBNode).filter(pbmd.PBNode.owner_id.in_(liOwnerIdList)).filter(pbmd.PBNode.node_id==liNodeId).one().data_file_content
-
-  def deleteNode(loNode):
-    # INFO - D.A. - 2013-11-07 - should be save as getNode should return only accessible nodes
-    pbm.DBSession.delete(loNode)
-    return
-
-  def createRight(self):
-    loRight = pbma.Rights()
-    return loRight

tracim/tracim/lib/helpers.py

 from tracim.lib.workspace import WorkspaceApi
 
 from tracim.model.data import ContentStatus
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
 
     else:
         return Markup('<i class="icon-%s"></i>' % icon_name)
 
-
-def getExplanationAboutStatus(psStatusId, psCurrentStatusId):
-  lsMsg = ""
-  if psStatusId==psCurrentStatusId:
-    return _("This is the current status.")
-  else:
-    if psStatusId=='information':
-      return _("The item is a normal document, like a howto or a text document.")
-    if psStatusId=='automatic':
-      return _("The item will be automatically computed as \"in progress\" or \"done\" according to its children status.")
-    if psStatusId=='new':
-      return _("No action done on the item.")
-    if psStatusId=='inprogress':
-      return _("The item is being worked on.")
-    if psStatusId=='standby':
-      return _("Waiting for some external actions.")
-    if psStatusId=='done':
-      return _("The work associated with the item is finished.")
-    if psStatusId=='closed':
-      return _("Close the item if you want not to see it anymore. The data won't be deleted")
-    if psStatusId=='deleted':
-      return _("This status tells that the item has been deleted.")
-
-class ID(object):
-  """ Helper class that will manage html items ids that need to be shared"""
-
-  @classmethod
-  def AddDocumentModalForm(cls, poNode=None):
-    if poNode:
-      return 'add-document-modal-form-%d'%poNode.node_id
-    else:
-      return 'add-document-modal-form'
-
-  @classmethod
-  def AddContactModalForm(cls, poNode=None):
-    if poNode:
-      return 'add-contact-modal-form-%d'%poNode.node_id
-    else:
-      return 'add-contact-modal-form'
-
-  @classmethod
-  def AddFileModalForm(cls, poNode=None):
-    if poNode:
-      return 'add-file-modal-form-%d'%poNode.node_id
-    else:
-      return 'add-file-modal-form'
-
-  @classmethod
-  def MoveDocumentModalForm(cls, poNode):
-      return 'move-document-modal-form-{0}'.format(poNode.node_id)
-
-  @classmethod
-  def AddEventModalForm(cls, poNode=None):
-    if poNode:
-      return 'add-event-modal-form-%d'%poNode.node_id
-    else:
-      return 'add-event-modal-form'
-    ## Original id is 'current-document-add-event-form'
-
-  @classmethod
-  def AddCommentInlineForm(cls):
-    return 'current-document-add-comment-form'
-
 class ICON(object):
   Shared = '<i class="fa fa-group"></i>'
   Private = '<i class="fa fa-key"></i>'
     elif role_level==UserRoleInWorkspace.WORKSPACE_MANAGER:
         return '#F00'
 
-def AllStatus(node_type=''):
-    return ContentStatus.all(node_type)
+def AllStatus(type=''):
+    return ContentStatus.all(type)
 
 
 def is_debug_mode():
 def on_off_to_boolean(on_or_off: str) -> bool:
     return True if on_or_off=='on' else False
 
-def convert_id_into_instances(id: str) -> (Workspace, PBNode):
+def convert_id_into_instances(id: str) -> (Workspace, Content):
     """
     TODO - D.A. - 2014-10-18 - Refactor and move this function where it must be placed
     convert an id like 'workspace_<workspace_id>|content_<content_id>'
     if id=='#':
         return None, None
 
-    workspace_str, content_str = id.split(CST.TREEVIEW_MENU.ITEM_SEPARATOR)
+    workspace_str = ''
+    content_str = ''
+    try:
+        workspace_str, content_str = id.split(CST.TREEVIEW_MENU.ITEM_SEPARATOR)
+    except:
+        pass
+
     workspace = None
     content = None
 
     try:
         content_data = content_str.split(CST.TREEVIEW_MENU.ID_SEPARATOR)
         content_id = int(content_data[1])
-        content = ContentApi(tg.tmpl_context.current_user).get_one(content_id, PBNodeType.Folder)
+        content = ContentApi(tg.tmpl_context.current_user).get_one(content_id, ContentType.Folder)
     except (IndexError, ValueError) as e:
         content = None
 

tracim/tracim/lib/user.py

 from tracim.model import auth as pbma
 from tracim.model import DBSession
 import tracim.model.data as pmd
-# import DIRTY_GroupRightsOnNode, DIRTY_UserDedicatedGroupRightOnNodeSqlQuery, DIRTY_RealGroupRightOnNodeSqlQuery, PBNode
 
 class UserApi(object):
 
         return self._base_query().filter(User.user_id==user_id).one()
 
     def get_one_by_email(self, email: str):
-        return self._base_query().filter(User.email_address==email).one()
+        return self._base_query().filter(User.email==email).one()
 
     def update(self, user: User, name: str, email: str, do_save):
         user.display_name = name
-        user.email_address = email
+        user.email = email
         if do_save:
             self.save(user)
 
+        if user.user_id==self._user.user_id:
+            # this is required for the session to keep on being up-to-date
+            tg.request.identity['repoze.who.userid'] = email
+
     def user_with_email_exists(self, email: str):
         try:
             self.get_one_by_email(email)
   @classmethod
   def get_current_user(cls) -> User:
     identity = tg.request.identity
-    print (tg.request.identity)
 
     if tg.request.identity:
         return pbma.User.by_email_address(tg.request.identity['repoze.who.userid'])
     return None
-
-  @classmethod
-  def getUserByEmailAddress(cls, psEmailAddress):
-    loUser = pbma.User.by_email_address(psEmailAddress)
-    return loUser
-
-  @classmethod
-  def createNewUser(cls, real_name, email_address, password, groups):
-    loUser = pbma.User()
-    new_user = pbma.User()
-    new_user.email_address = email_address
-    new_user.display_name  = real_name if real_name!='' else email_address
-    new_user.password      = password
-
-    public_group = cls.getGroupById(pbma.Group.TIM_USER)
-    public_group.users.append(new_user)
-
-    DBSession.add(new_user)
-    DBSession.flush()
-    DBSession.refresh(new_user)
-
-    user_dedicated_group = cls.createGroup()
-    user_dedicated_group.group_id = 0-new_user.user_id # group id of a given user is the opposite of the user id
-    user_dedicated_group.group_name = 'user_%d' % new_user.user_id
-    user_dedicated_group.personnal_group = True
-    user_dedicated_group.users.append(new_user)
-
-    for group_id in groups:
-        selected_group = cls.getGroupById(group_id)
-        selected_group.users.append(new_user)
-
-    DBSession.flush()
-
-    return new_user
-
-  @classmethod
-  def updateUser(cls, user_id, real_name, email, group_ids):
-
-      group_ids = list(map(int, group_ids))
-      group_ids.append(pbma.Group.TIM_USER)
-      print('new group ids:', group_ids)
-      user_to_update = DBSession.query(pbma.User).filter(pbma.User.user_id==user_id).one()
-      user_to_update.display_name = real_name
-      user_to_update.email_address = email
-
-      merged_new_groups = []
-
-      for group in user_to_update.groups:
-          if group.group_id==pbma.Group.TIM_ADMIN:
-              print('adding group (3)', group.group_id)
-              merged_new_groups.append(group)
-
-          elif group.group_id==pbma.Group.TIM_USER:
-              print('adding group (2)', group.group_id)
-              merged_new_groups.append(group)
-
-          elif group.group_id in group_ids:
-              print('adding group', group.group_id)
-              merged_new_groups.append(group)
-
-          else:
-              print('remove group', group.group_id)
-              user_to_update.groups.remove(group)
-
-      for group_id in group_ids:
-          group = cls.getGroupById(group_id)
-
-          if group not in merged_new_groups:
-              merged_new_groups.append(group)
-
-      user_to_update.groups = merged_new_groups
-
-      for group in merged_new_groups:
-          print("group => ", group.group_id)
-      DBSession.flush()
-
-  @classmethod
-  def deleteUser(cls, user_id):
-      user_to_delete = DBSession.query(pbma.User).filter(pbma.User.user_id==user_id).one()
-      user_dedicated_group = DBSession.query(pbma.Group).filter(pbma.Group.group_id==-user_id).one()
-      DBSession.delete(user_to_delete)
-      DBSession.delete(user_dedicated_group)
-      DBSession.flush()
-
-  @classmethod
-  def getGroup(cls, psGroupName):
-    loGroup = pbma.Group.by_group_name(psGroupName)
-    return loGroup
-
-  @classmethod
-  def getGroupById(cls, group_id):
-    return DBSession.query(pbma.Group).filter(pbma.Group.group_id==group_id).one()
-
-  @classmethod
-  def createGroup(cls):
-    loGroup = pbma.Group()
-    return loGroup
-
-  @classmethod
-  def getGroups(cls):
-    loGroups = pbma.Group.real_groups_first()
-    return loGroups
-
-  @classmethod
-  def getRealGroupRightsOnNode(cls, piNodeId: int) -> pmd.DIRTY_GroupRightsOnNode:
-
-    groupRightsOnNodeCustomSelect = DBSession\
-        .query(pmd.DIRTY_GroupRightsOnNode)\
-        .from_statement(pmd.DIRTY_RealGroupRightOnNodeSqlQuery)\
-        .params(node_id=piNodeId)\
-        .all()
-
-    return groupRightsOnNodeCustomSelect
-
-  @classmethod
-  def getUserDedicatedGroupRightsOnNode(cls, node: pmd.PBNode) -> pmd.DIRTY_GroupRightsOnNode:
-
-    group_rights_on_node = []
-    if node:
-        group_rights_on_node = DBSession\
-            .query(pmd.DIRTY_GroupRightsOnNode)\
-            .from_statement(pmd.DIRTY_UserDedicatedGroupRightOnNodeSqlQuery)\
-            .params(node_id=node.node_id)\
-            .all()
-
-    return group_rights_on_node
-
-  @classmethod
-  def DIRTY_get_rights_on_node(self, user_id, node_id):
-      rights = DBSession\
-              .execute("""select max(rights) as rights
-                      from pod_user_group
-                      natural join pod_group_node
-                      where node_id=:node_id
-                      and user_id=:user_id""", {"node_id":node_id, "user_id":user_id})\
-              .fetchone()
-      r = pmd.DIRTY_GroupRightsOnNode()
-      r.rights = rights[0]
-      return r
-

tracim/tracim/lib/userworkspace.py

         return self._get_all_for_user(user_id).all()
 
     def get_all_for_user_order_by_workspace(self, user_id: int) -> UserRoleInWorkspace:
-        return self._get_all_for_user(user_id).join(UserRoleInWorkspace.workspace).order_by(Workspace.data_label).all()
+        return self._get_all_for_user(user_id).join(UserRoleInWorkspace.workspace).order_by(Workspace.label).all()
 
     def get_all_for_workspace(self, workspace_id):
         return DBSession.query(UserRoleInWorkspace).filter(UserRoleInWorkspace.workspace_id==workspace_id).all()

tracim/tracim/lib/workspace.py

 
     def create_workspace(self, label: str, description: str='', save_now:bool=False) -> Workspace:
         workspace = Workspace()
-        workspace.data_label = label
-        workspace.data_comment = description
+        workspace.label = label
+        workspace.description = description
 
         # By default, we force the current user to be the workspace manager
         role = RoleApi(self._user).create_one(self._user, workspace, UserRoleInWorkspace.WORKSPACE_MANAGER)
 
     def get_all_for_user(self, user: User):
         workspaces = [role.workspace for role in user.roles]
-        workspaces.sort(key=lambda workspace: workspace.data_label.lower())
+        workspaces.sort(key=lambda workspace: workspace.label.lower())
         return workspaces
 
     def save(self, workspace: Workspace):

tracim/tracim/model/__init__.py

 
 # Import your model modules here.
 from tracim.model.auth import User, Group, Permission
-from tracim.model.data import PBNode
+from tracim.model.data import Content

tracim/tracim/model/auth.py

 import os
 from datetime import datetime
 from hashlib import sha256
+from sqlalchemy.ext.hybrid import hybrid_property
 from tg.i18n import lazy_ugettext as l_
 
 __all__ = ['User', 'Group', 'Permission']
 
 # This is the association table for the many-to-many relationship between
 # groups and permissions.
-group_permission_table = Table('pod_group_permission', metadata,
-    Column('group_id', Integer, ForeignKey('pod_group.group_id',
+group_permission_table = Table('group_permission', metadata,
+    Column('group_id', Integer, ForeignKey('groups.group_id',
         onupdate="CASCADE", ondelete="CASCADE"), primary_key=True),
-    Column('permission_id', Integer, ForeignKey('pod_permission.permission_id',
+    Column('permission_id', Integer, ForeignKey('permissions.permission_id',
         onupdate="CASCADE", ondelete="CASCADE"), primary_key=True)
 )
 
 # This is the association table for the many-to-many relationship between
 # groups and members - this is, the memberships.
-user_group_table = Table('pod_user_group', metadata,
-    Column('user_id', Integer, ForeignKey('pod_user.user_id',
+user_group_table = Table('user_group', metadata,
+    Column('user_id', Integer, ForeignKey('users.user_id',
         onupdate="CASCADE", ondelete="CASCADE"), primary_key=True),
-    Column('group_id', Integer, ForeignKey('pod_group.group_id',
+    Column('group_id', Integer, ForeignKey('groups.group_id',
         onupdate="CASCADE", ondelete="CASCADE"), primary_key=True)
 )
 
-
-
-
-class Rights(DeclarativeBase):
-
-    READ_ACCESS = 1
-    WRITE_ACCESS = 2
-
-    __tablename__ = 'pod_group_node'
-
-    group_id = Column(Integer, ForeignKey('pod_group.group_id'), primary_key=True)
-    node_id = Column(Integer, ForeignKey('pod_nodes.node_id'), primary_key=True)
-    rights = Column(Integer)
-
-    def hasReadAccess(self):
-        return self.rights & Rights.READ_ACCESS
-
-    def hasWriteAccess(self):
-        return self.rights & Rights.WRITE_ACCESS
-
-
 class Group(DeclarativeBase):
 
     TIM_NOBODY = 0
     TIM_MANAGER_GROUPNAME = 'managers'
     TIM_ADMIN_GROUPNAME = 'administrators'
 
-    __tablename__ = 'pod_group'
+    __tablename__ = 'groups'
 
     group_id = Column(Integer, autoincrement=True, primary_key=True)
     group_name = Column(Unicode(16), unique=True, nullable=False)
 
     users = relationship('User', secondary=user_group_table, backref='groups')
 
-    _lRights = relationship('Rights', backref='_oGroup', cascade = "all, delete-orphan")
-
-
-
     def __repr__(self):
         return '<Group: name=%s>' % repr(self.group_name)
 
         """Return the user object whose email address is ``email``."""
         return DBSession.query(cls).filter_by(group_name=group_name).first()
 
-    def getDisplayName(self) -> str:
-        if self.group_id<0:
-            # FIXME - D.A. - 2014-05-19 - MAKE THIS CODE CLEANER,
-            try:
-                return self.users[0].get_display_name()
-            except:
-                print('ERROR GROUP =>', self.group_id)
-
-
-        return self.display_name
-
-    @property
-    def rights(self):
-        return self._lRights
-
-    def hasSomeAccess(self, poNode):
-        for loRight in self._lRights:
-            if loRight.node_id == poNode.node_id and loRight.rights>0:
-                return True
-        return False
-
 
 
 class Profile(object):
     User definition.
 
     This is the user definition used by :mod:`repoze.who`, which requires at
-    least the ``email_address`` column.
+    least the ``email`` column.
 
     """
-    __tablename__ = 'pod_user'
+    __tablename__ = 'users'
 
     user_id = Column(Integer, autoincrement=True, primary_key=True)
-    email_address = Column(Unicode(255), unique=True, nullable=False)
+    email = Column(Unicode(255), unique=True, nullable=False)
     display_name = Column(Unicode(255))
     _password = Column('password', Unicode(128))
     created = Column(DateTime, default=datetime.now)
     is_active = Column(Boolean, default=True, nullable=False)
+
+    @hybrid_property
+    def email_address(self):
+        return self.email
+
     def __repr__(self):
         return '<User: email=%s, display=%s>' % (
-                repr(self.email_address), repr(self.display_name))
+                repr(self.email), repr(self.display_name))
 
     def __unicode__(self):
-        return self.display_name or self.email_address
+        return self.display_name or self.email
 
     @property
     def permissions(self):
     @classmethod
     def by_email_address(cls, email):
         """Return the user object whose email address is ``email``."""
-        return DBSession.query(cls).filter_by(email_address=email).first()
+        return DBSession.query(cls).filter_by(email=email).first()
 
     @classmethod
     def by_user_name(cls, username):
         """Return the user object whose user name is ``username``."""
-        return DBSession.query(cls).filter_by(email_address=username).first()
+        return DBSession.query(cls).filter_by(email=username).first()
 
     @classmethod
     def _hash_password(cls, password):
         if self.display_name!=None and self.display_name!='':
             return self.display_name
         else:
-            return self.email_address
+            return self.email
 
 
 class Permission(DeclarativeBase):
 
     """
 
-    __tablename__ = 'pod_permission'
+    __tablename__ = 'permissions'
 
 
     permission_id = Column(Integer, autoincrement=True, primary_key=True)

tracim/tracim/model/data.py

 # -*- coding: utf-8 -*-
 
 from bs4 import BeautifulSoup
-
+import datetime as datetime_root
 import json
-import re
-import datetime as datetimeroot
-from datetime import datetime
-from hashlib import sha256
-
-from sqlalchemy import Table, ForeignKey, Column, Sequence
-import sqlalchemy as sqla
-from sqlalchemy.sql.sqltypes import Boolean
-from sqlalchemy.types import Unicode, Integer, DateTime, Text, LargeBinary
-import sqlalchemy.types as sqlat
-from sqlalchemy.ext.orderinglist import ordering_list
-from sqlalchemy.orm import relation, synonym, relationship
-from sqlalchemy.orm import backref
-import sqlalchemy.orm as sqlao
-import sqlalchemy.orm.query as sqlaoq
-from sqlalchemy import orm as sqlao
+
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+
 from sqlalchemy.ext.hybrid import hybrid_property
 
-from tg.i18n import ugettext as _, lazy_ugettext as l_
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import deferred
 
-import tg
-from tracim.model import DeclarativeBase, metadata, DBSession
-# from tracim.model import auth as pma
+from sqlalchemy.types import Boolean
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import Integer
+from sqlalchemy.types import LargeBinary
+from sqlalchemy.types import Text
+from sqlalchemy.types import Unicode
 
-from tracim.model.auth import User
-from tracim.model.auth import Rights
-from tracim.model.auth import user_group_table
+from tg.i18n import lazy_ugettext as l_
 
-from tracim.lib.base import current_user
+from tracim.model import DeclarativeBase
+from tracim.model.auth import User
 
 class BreadcrumbItem(object):
 
 
 class Workspace(DeclarativeBase):
 
-    __tablename__ = 'pod_workspaces'
+    __tablename__ = 'workspaces'
 
-    workspace_id = Column(Integer, Sequence('pod_workspaces__workspace_id__sequence'), primary_key=True)
+    workspace_id = Column(Integer, autoincrement=True, primary_key=True)
 
-    data_label   = Column(Unicode(1024), unique=False, nullable=False, default='')
-    data_comment = Column(Text(),        unique=False, nullable=False, default='')
+    label   = Column(Unicode(1024), unique=False, nullable=False, default='')
+    description = Column(Text(), unique=False, nullable=False, default='')
 
-    created_at = Column(DateTime, unique=False, nullable=False)
-    updated_at = Column(DateTime, unique=False, nullable=False)
+    created = Column(DateTime, unique=False, nullable=False)
+    updated = Column(DateTime, unique=False, nullable=False)
 
-    is_deleted = Column(sqlat.Boolean, unique=False, nullable=False, default=False)
+    is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
 
     def get_user_role(self, user: User) -> int:
         for role in user.roles:
 
 class UserRoleInWorkspace(DeclarativeBase):
 
-    __tablename__ = 'pod_user_workspace'
+    __tablename__ = 'user_workspace'
 
-    user_id = Column(Integer, ForeignKey('pod_user.user_id'), nullable=False, default=None, primary_key=True)
-    workspace_id = Column(Integer, ForeignKey('pod_workspaces.workspace_id'), nullable=False, default=None, primary_key=True)
+    user_id = Column(Integer, ForeignKey('users.user_id'), nullable=False, default=None, primary_key=True)
+    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), nullable=False, default=None, primary_key=True)
     role = Column(Integer, nullable=False, default=0, primary_key=False)
 
     workspace = relationship('Workspace', remote_side=[Workspace.workspace_id], backref='roles', lazy='joined')
     _ICONS = {
         'archiving': 'mimetypes/package-x-generic',
         'content-comment': 'apps/internet-group-chat',
-        'creation': 'apps/accessories-text-editor',
+        'creation': 'actions/document-new',
         'deletion': 'status/user-trash-full',
         'edition': 'apps/accessories-text-editor',
         'revision': 'apps/accessories-text-editor',
     def __init__(self, id):
         assert id in ActionDescription.allowed_values()
         self.id = id
-        self.label = ''
+        self.label = ActionDescription._LABELS[id]
         self.icon = ActionDescription._ICONS[id]
 
     @classmethod
         'closed-deprecated': 'tracim-status-closed-deprecated',
     }
 
-    def __init__(self, id, node_type=''):
+    def __init__(self, id, type=''):
         self.id = id
-        print('ID', id)
         self.icon = ContentStatus._ICONS[id]
         self.css = ContentStatus._CSS[id]
 
-        if node_type==PBNodeType.Thread:
+        if type==ContentType.Thread:
             self.label = ContentStatus._LABELS_THREAD[id]
-        elif node_type==PBNodeType.File:
+        elif type==ContentType.File:
             self.label = ContentStatus._LABELS_FILE[id]
         else:
             self.label = ContentStatus._LABELS[id]
 
 
     @classmethod
-    def all(cls, node_type='') -> ['ContentStatus']:
+    def all(cls, type='') -> ['ContentStatus']:
         all = []
-        all.append(ContentStatus('open', node_type))
-        all.append(ContentStatus('closed-validated', node_type))
-        all.append(ContentStatus('closed-unvalidated', node_type))
-        all.append(ContentStatus('closed-deprecated', node_type))
+        all.append(ContentStatus('open', type))
+        all.append(ContentStatus('closed-validated', type))
+        all.append(ContentStatus('closed-unvalidated', type))
+        all.append(ContentStatus('closed-deprecated', type))
         return all
 
     @classmethod
     def allowed_values(cls):
         return ContentStatus._LABELS.keys()
 
-class PBNodeStatusItem(object):
-  def __init__(self, psStatusId, psStatusLabel, psStatusFamily, psIconId, psCssClass): #, psBackgroundColor):
-    self._sStatusId     = psStatusId
-    self._sStatusLabel  = psStatusLabel
-    self._sStatusFamily = psStatusFamily
-    self._sIconId   = psIconId
-    self._sCssClass = psCssClass
-    # self._sBackgroundColor = psBackgroundColor
-  
-  def getLabel(self):
-    return self._sStatusLabel
-    
-  @property
-  def status_family(self):
-    return self._sStatusFamily
-    
-  @property
-  def icon(self):
-    return self._sIconId
-    
-  def getId(self):
-    return self._sStatusId
-
-  @property
-  def css(self):
-    return self._sCssClass
-
-  @property
-  def status_id(self):
-    return self._sStatusId
-    
-  @property
-  def icon_id(self):
-    return self._sIconId
-
-  @property
-  def label(self):
-    return self._sStatusLabel
-
-class PBNodeStatus(object):
-    
-  StatusList = dict()
-  StatusList['information'] = PBNodeStatusItem('information', 'Information',         'normal', 'fa fa-info-circle',            'tracim-status-grey-light')
-  StatusList['automatic']   = PBNodeStatusItem('automatic',   'Automatic',           'open',   'fa fa-flash',                  'tracim-status-grey-light')
-  StatusList['new']         = PBNodeStatusItem('new',         'New',                 'open',   'fa fa-lightbulb-o fa-inverse', 'btn-success')
-  StatusList['inprogress']  = PBNodeStatusItem('inprogress',  'In progress',         'open',   'fa fa-gears fa-inverse',       'btn-info')
-  StatusList['standby']     = PBNodeStatusItem('standby',     'In standby',          'open',   'fa fa-spinner fa-inverse',     'btn-warning')
-  StatusList['done']        = PBNodeStatusItem('done',        'Done',                'closed', 'fa fa-check-square-o',         'tracim-status-grey-light')
-  StatusList['closed']      = PBNodeStatusItem('closed',      'Closed',              'closed', 'fa fa-lightbulb-o',            'tracim-status-grey-middle')
-  StatusList['deleted']     = PBNodeStatusItem('deleted',     'Deleted',             'closed', 'fa fa-trash-o',                'tracim-status-grey-dark')
-
-  @classmethod
-  def getChoosableList(cls):
-    return [
-      PBNodeStatus.StatusList['information'],
-      PBNodeStatus.StatusList['automatic'],
-      PBNodeStatus.StatusList['new'],
-      PBNodeStatus.StatusList['inprogress'],
-      PBNodeStatus.StatusList['standby'],
-      PBNodeStatus.StatusList['done'],
-      PBNodeStatus.StatusList['closed'],
-    ]
-
-  @classmethod
-  def getVisibleIdsList(cls):
-    return ['information', 'automatic', 'new', 'inprogress', 'standby', 'done' ]
-
-  @classmethod
-  def getVisibleList(cls):
-    return [
-      PBNodeStatus.StatusList['information'],
-      PBNodeStatus.StatusList['automatic'],
-      PBNodeStatus.StatusList['new'],
-      PBNodeStatus.StatusList['inprogress'],
-      PBNodeStatus.StatusList['standby'],
-      PBNodeStatus.StatusList['done'],
-    ]
-
-  @classmethod
-  def getList(cls):
-    return [
-      PBNodeStatus.StatusList['information'],
-      PBNodeStatus.StatusList['automatic'],
-      PBNodeStatus.StatusList['new'],
-      PBNodeStatus.StatusList['inprogress'],
-      PBNodeStatus.StatusList['standby'],
-      PBNodeStatus.StatusList['done'],
-      PBNodeStatus.StatusList['closed'],
-      PBNodeStatus.StatusList['deleted']
-    ]
-
-    
-  @classmethod
-  def getStatusItem(cls, psStatusId):
-    return PBNodeStatus.StatusList[psStatusId]
-
-class PBNodeType(object):
+class ContentType(object):
     Any = 'any'
 
     Folder  = 'folder'
     Thread = 'thread'
     Page = 'page'
 
-    # Obsolete ones - to be removed
-    Node    = 'node'
-    Data    = 'data'
-    Event   = 'event'
-    Contact = 'contact'
-
     # Fake types, used for breadcrumb only
     FAKE_Dashboard = 'dashboard'
     FAKE_Workspace = 'workspace'
 
     @classmethod
     def icon(cls, type: str):
-        assert(type in PBNodeType._ICONS) # DYN_REMOVE
-        return PBNodeType._ICONS[type]
+        assert(type in ContentType._ICONS) # DYN_REMOVE
+        return ContentType._ICONS[type]
 
     @classmethod
     def allowed_types(cls):
     def allowed_types_from_str(cls, allowed_types_as_string: str):
         allowed_types = []
         # HACK - THIS
-        for item in allowed_types_as_string.split(PBNodeType._STRING_LIST_SEPARATOR):
-            if item and item in PBNodeType.allowed_types():
+        for item in allowed_types_as_string.split(ContentType._STRING_LIST_SEPARATOR):
+            if item and item in ContentType.allowed_types():
                 allowed_types.append(item)
         return allowed_types
 
-MINIMUM_DATE = datetimeroot.date(datetimeroot.MINYEAR, 1, 1)
-
-class PBNode(DeclarativeBase):
-
-    #def __init__(self):
-    #  self._lStaticChildList = []
-
-    @sqlao.reconstructor
-    def init_on_load(self):
-      self._lStaticChildList = []
-
-    def appendStaticChild(self, loNode):
-        print("%s has child %s" % (self.node_id, loNode.node_id))
-        self._lStaticChildList.append(loNode)
-
-    def getStaticChildList(self):
-        return self._lStaticChildList
-
-    def getStaticChildNb(self):
-        return len(self._lStaticChildList)
-
-    __tablename__ = 'pod_nodes'
+class Content(DeclarativeBase):
+    __tablename__ = 'contents'
 
     revision_to_serialize = -0  # This flag allow to serialize a given revision if required by the user
 
-    node_id          = Column(Integer, Sequence('pod_nodes__node_id__sequence'), primary_key=True)
-    parent_id        = Column(Integer, ForeignKey('pod_nodes.node_id'), nullable=True, default=None)
-    node_depth       = Column(Integer, unique=False, nullable=False, default=0)
+    content_id = Column(Integer, autoincrement=True, primary_key=True)
+    parent_id = Column(Integer, ForeignKey('contents.content_id'), nullable=True, default=None)
+    node_depth = Column(Integer, unique=False, nullable=False, default=0)
     parent_tree_path = Column(Unicode(255), unique=False, nullable=False, default='')
-    owner_id         = Column(Integer, ForeignKey('pod_user.user_id'), nullable=True, default=None)
+    owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True, default=None)
 
-    node_order   = Column(Integer, nullable=True, default=1)
-    node_type    = Column(Unicode(32), unique=False, nullable=False)
-    node_status = Column(Unicode(32), unique=False, nullable=False, default=ContentStatus.OPEN)
+    type = Column(Unicode(32), unique=False, nullable=False)
+    status = Column(Unicode(32), unique=False, nullable=False, default=ContentStatus.OPEN)
 
-    created_at = Column(DateTime, unique=False, nullable=False)
-    updated_at = Column(DateTime, unique=False, nullable=False)
+    created = Column(DateTime, unique=False, nullable=False)
+    updated = Column(DateTime, unique=False, nullable=False)
 
-    workspace_id = Column(Integer, ForeignKey('pod_workspaces.workspace_id'), unique=False, nullable=True)
+    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
 
     workspace = relationship('Workspace', remote_side=[Workspace.workspace_id], backref='contents')
 
 
-    is_deleted = Column(sqlat.Boolean, unique=False, nullable=False, default=False)
-    is_archived = Column(sqlat.Boolean, unique=False, nullable=False, default=False)
-
-    is_shared = Column(sqlat.Boolean, unique=False, nullable=False, default=False)
-    is_public = Column(sqlat.Boolean, unique=False, nullable=False, default=False)
-    public_url_key = Column(Unicode(1024), unique=False, nullable=False, default='')
+    is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
+    is_archived = Column(Boolean, unique=False, nullable=False, default=False)
 
-    data_label = Column(Unicode(1024), unique=False, nullable=False, default='')
-    data_content = Column(Text(), unique=False, nullable=False, default='')
+    label = Column(Unicode(1024), unique=False, nullable=False, default='')
+    description = Column(Text(), unique=False, nullable=False, default='')
     _properties = Column('properties', Text(), unique=False, nullable=False, default='')
 
-    data_datetime = Column(DateTime, unique=False, nullable=False)
-    data_reminder_datetime = Column(DateTime, unique=False, nullable=True)
+    file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
+    file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
+    file_content = deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
 
-    data_file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
-    data_file_mime_type = Column(Unicode(255),  unique=False, nullable=False, default='')
-    data_file_content = sqlao.deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
+    revision_type = Column(Unicode(32), unique=False, nullable=False, default='')
 
-    last_action = Column(Unicode(32), unique=False, nullable=False, default='')
-
-    _lRights = relationship('Rights', backref='_oNode', cascade = "all, delete-orphan")
-
-    parent = relationship('PBNode', remote_side=[node_id], backref='children')
-    owner = relationship('User', remote_side=[User.user_id], backref='_lAllNodes')
-
-    @hybrid_property
-    def _lAllChildren(self):
-        # for backward compatibility method
-        return self.children
-
-    @property
-    def _oOwner(self):
-        # for backward compatibility method
-        return self.owner
-
-    @property
-    def _oParent(self):
-        # for backward compatibility method
-        return self.parent
+    parent = relationship('Content', remote_side=[content_id], backref='children')
+    owner = relationship('User', remote_side=[User.user_id])
 
     @hybrid_property
     def properties(self):
 
     def extract_links_from_content(self, other_content: str=None) -> [LinkItem]:
         """
-        parse html content and extract links. By default, it works on the data_content property
-        :param other_content: if not empty, then parse the given html content instead of data_content
+        parse html content and extract links. By default, it works on the description property
+        :param other_content: if not empty, then parse the given html content instead of description
         :return: a list of LinkItem
         """
         links = []
-        soup = BeautifulSoup(self.data_content if not other_content else other_content)
+        soup = BeautifulSoup(self.description if not other_content else other_content)
         for link in soup.findAll('a'):
             href = link.get('href')
-            print(href)
             label = link.contents
             links.append(LinkItem(href, label))
         links.sort(key=lambda link: link.href if link.href else '')
         return sorted_links
 
 
-    def getChildrenOfType(self, plNodeTypeList, poKeySortingMethod=None, pbDoReverseSorting=False):
-        """return all children nodes of type 'data' or 'node' or 'folder'"""
-        llChildren = []
-        user_id = current_user().user_id
-        llChildren = DBSession.query(PBNode).outerjoin(Rights)\
-                .outerjoin(user_group_table, Rights.group_id==user_group_table.columns['group_id'])\
-                .filter(PBNode.parent_id==self.node_id)\
-                .filter((PBNode.owner_id==user_id) | ((user_group_table.c.user_id==user_id) & (PBNode.is_shared == True)))\
-                .filter(PBNode.node_type.in_(plNodeTypeList))\
-                .all()
-        if poKeySortingMethod!=None:
-          llChildren = sorted(llChildren, key=poKeySortingMethod, reverse=pbDoReverseSorting)
-        return llChildren
-
-    def get_child_nb(self, content_type: PBNodeType, content_status = ''):
-        # V2 method - to keep
+    def get_child_nb(self, content_type: ContentType, content_status = ''):
         child_nb = 0
-        for child in self._lAllChildren:
-            if child.node_type==content_type:
+        for child in self.children:
+            if child.type==content_type:
                 if not content_status:
                     child_nb = child_nb+1
-                elif content_status==child.node_status:
+                elif content_status==child.status:
                     child_nb = child_nb+1
         return child_nb
 
     def get_status(self) -> ContentStatus:
-        return ContentStatus(self.node_status, self.node_type.__str__())
+        return ContentStatus(self.status, self.type.__str__())
+
 
     def get_last_action(self) -> ActionDescription:
-        return ActionDescription(self.last_action)
+        return ActionDescription(self.revision_type)
+
 
     def get_comments(self):
         children = []
         for child in self.children:
-            if child.node_type==PBNodeType.Comment:
+            if child.type==ContentType.Comment:
                 children.append(child)
         return children
 
 
 
-
-
-    def getChildNb(self):
-        return self.getChildNbOfType([PBNodeType.Data])
-
-    def getGroupsWithSomeAccess(self):
-        llRights = []
-        for loRight in self._lRights:
-            if loRight.rights>0:
-                llRights.append(loRight)
-        return llRights
-
-    def getChildren(self, pbIncludeDeleted=False):
-        """return all children nodes of type 'data' or 'node' or 'folder'"""
-        # return self.getChildrenOfType([PBNodeType.Node, PBNodeType.Folder, PBNodeType.Data])
-        items = self.getChildrenOfType([PBNodeType.Node, PBNodeType.Folder, PBNodeType.Data])
-        items2 = list()
-        for item in items:
-            if pbIncludeDeleted==True or item.node_status!='deleted':
-                items2.append(item)
-        return items2
-
-    def getContacts(self):
-        """return all children nodes of type 'data' or 'node' or 'folder'"""
-        return self.getChildrenOfType([PBNodeType.Contact], PBNode.getSortingKeyForContact)
-
-    def getContactNb(self):
-        """return all children nodes of type 'data' or 'node' or 'folder'"""
-        return self.getChildNbOfType([PBNodeType.Contact])
-
-    @classmethod
-    def getSortingKeyBasedOnDataDatetime(cls, poDataNode):
-        return poDataNode.data_datetime or MINIMUM_DATE
-    
-    @classmethod
-    def getSortingKeyForContact(cls, poDataNode):
-        return poDataNode.data_label or ''
-
-    @classmethod
-    def getSortingKeyForComment(cls, poDataNode):
-        return poDataNode.data_datetime or ''
-
-    def getEvents(self):
-        return self.getChildrenOfType([PBNodeType.Event], PBNode.getSortingKeyBasedOnDataDatetime, True)
-    
-    def getFiles(self):
-        return self.getChildrenOfType([PBNodeType.File])
-
-    def getIconClass(self):
-        if self.node_type==PBNodeType.Data and self.getStaticChildNb()>0:
-            return PBNode.getIconClassForNodeType('folder')
-        else:
-            return PBNode.getIconClassForNodeType(self.node_type)
-
-    def getBreadCrumbNodes(self) -> list('PBNode'):
-        loNodes = []
-        if self._oParent!=None:
-            loNodes = self._oParent.getBreadCrumbNodes()
-            loNodes.append(self._oParent)
-        return loNodes
-
-    def getContentWithHighlightedKeywords(self, plKeywords, psPlainText):
-        if len(plKeywords)<=0:
-            return psPlainText
-
-        lsPlainText = psPlainText
-
-        for lsKeyword in plKeywords:
-            lsPlainText = re.sub('(?i)(%s)' % lsKeyword, '<strong>\\1</strong>', lsPlainText)
-
-        return lsPlainText
-
-
-    @classmethod
-    def getIconClassForNodeType(cls, psIconType):
-        laIconClass = dict()
-        laIconClass['node']   = 'fa fa-folder-open'
-        laIconClass['folder'] = 'fa fa-folder-open'
-        laIconClass['data']   = 'fa fa-file-text-o'
-
-        laIconClass['file']   = 'fa fa-paperclip'
-        laIconClass['event']  = 'fa fa-calendar'
-        laIconClass['contact'] = 'fa fa-user'
-        laIconClass['comment'] = 'fa fa-comments-o'
-        return laIconClass[psIconType]
-
-
-    def getUserFriendlyNodeType(self):
-        laNodeTypesLng = dict()
-        laNodeTypesLng['node']   = 'Document' # FIXME - D.A. - 2013-11-14 - Make text translatable
-        laNodeTypesLng['folder'] = 'Document'
-        laNodeTypesLng['data']   = 'Document'
-
-        laNodeTypesLng['file']   = 'File'
-        laNodeTypesLng['event']  = 'Event'
-        laNodeTypesLng['contact'] = 'Contact'
-        laNodeTypesLng['comment'] = 'Comment'
-
-        if self.node_type==PBNodeType.Data and self.getStaticChildNb()>0:
-            return laNodeTypesLng['folder']
-        else:
-            return laNodeTypesLng[self.node_type]
-
-    
-    def getFormattedDateTime(self, poDateTime, psDateTimeFormat = '%d/%m/%Y ~ %H:%M'):
-        return poDateTime.strftime(psDateTimeFormat)
-
-    def getFormattedDate(self, poDateTime, psDateTimeFormat = '%d/%m/%Y'):
-        return poDateTime.strftime(psDateTimeFormat)
-
-    def getFormattedTime(self, poDateTime, psDateTimeFormat = '%H:%M'):
-        return poDateTime.strftime(psDateTimeFormat)
-
-    def getStatus(self) -> PBNodeStatusItem:
-        loStatus = PBNodeStatus.getStatusItem(self.node_status)
-        if loStatus.status_id!='automatic':
-            return loStatus
-
-        # default case
-        # Compute the status:
-        # - if at least one child is 'new' or 'in progress' or 'in standby' => status is inprogress
-        # - else if all status are 'done', 'closed' or 'deleted' => 'done'
-        lsRealStatusId = 'done'
-        for loChild in self.getChildren():
-            if loChild.getStatus().status_id in ('new', 'inprogress', 'standby'):
-                lsRealStatusId = 'inprogress'
-                break
-        return PBNodeStatus.getStatusItem(lsRealStatusId)
-
-    def getTruncatedLabel(self, piCharNb: int):
-        """
-        return a truncated version of the data_label property.
-        if piCharNb is not > 0, then the full data_label is returned
-        note: if the node is a file and the data_label is empty, the file name is returned
-        """
-        lsTruncatedLabel = self.data_label
-
-        # 2014-05-06 - D.A. - HACK
-        # if the node is a file and label empty, then use the filename as data_label
-        if self.node_type==PBNodeType.File and lsTruncatedLabel=='':
-            lsTruncatedLabel = self.data_file_name
-
-        liMaxLength = int(piCharNb)
-        if liMaxLength>0 and len(lsTruncatedLabel)>liMaxLength:
-            lsTruncatedLabel = lsTruncatedLabel[0:liMaxLength-1]+'…'
-
-        if lsTruncatedLabel=='':
-            lsTruncatedLabel = _('Titleless Document')
-
-        return lsTruncatedLabel
-
-    def getTruncatedContentAsText(self, piCharNb):
-        lsPlainText = ''.join(BeautifulSoup(self.data_content).findAll(text=True))
-        lsTruncatedContent = ''
-
-        liMaxLength = int(piCharNb)
-        if len(lsPlainText)>liMaxLength:
-            lsTruncatedContent = lsPlainText[0:liMaxLength-1]+'…'
-        else:
-            lsTruncatedContent = lsPlainText
-        return lsTruncatedContent
-
-    def getTagList(self):
-        loPattern = re.compile('(^|\s|@)@(\w+)')
-        loResults = re.findall(loPattern, self.data_content)
-        lsResultList = []
-        for loResult in loResults:
-            lsResultList.append(loResult[1].replace('@', '').replace('_', ' '))
-        return lsResultList
-
-    @classmethod
-    def addTagReplacement(cls, matchobj):
-        return " <span class='badge'>%s</span> " %(matchobj.group(0).replace('@', '').replace('_', ' '))
-
-    @classmethod
-    def addDocLinkReplacement(cls, matchobj):
-        return " <a href='%s'>%s</a> " %(tg.url('/dashboard?node=%s')%(matchobj.group(1)), matchobj.group(0))
-
-    def getContentWithTags(self):
-        lsTemporaryResult = re.sub('(^|\s)@@(\w+)', '', self.data_content) # tags with @@ are explicitly removed from the body
-        lsTemporaryResult = re.sub('#([0-9]*)', PBNode.addDocLinkReplacement, lsTemporaryResult) # tags with @@ are explicitly removed from the body
-        return re.sub('(^|\s)@(\w+)', PBNode.addTagReplacement, lsTemporaryResult) # then, 'normal tags are transformed as labels'
-        # FIXME - D.A. - 2013-09-12
-        # Does not match @@ at end of content.
-  
-    def getHistory(self):
-        return DBSession.execute("select node_id, version_id, created_at from pod_nodes_history where node_id = :node_id order by created_at desc", {"node_id":self.node_id}).fetchall()
-
-
 class ContentChecker(object):
 
     @classmethod
-    def check_properties(cls, item: PBNode):
-        if item.node_type==PBNodeType.Folder:
+    def check_properties(cls, item: Content):
+        if item.type==ContentType.Folder:
             properties = item.properties
             if 'allowed_content' not in properties.keys():
                 return False
         raise NotImplementedError
 
     @classmethod
-    def reset_properties(cls, item: PBNode):
-        if item.node_type==PBNodeType.Folder:
+    def reset_properties(cls, item: Content):
+        if item.type==ContentType.Folder:
             item.properties = dict(
                 allowed_content = dict (
                     folder = True,
             )
             return
 
-        print('NODE TYPE', item.node_type)
         raise NotImplementedError
 
+
 class ContentRevisionRO(DeclarativeBase):
 
-    __tablename__ = 'pod_nodes_history'
-
-    version_id = Column(Integer, primary_key=True)
-    node_id = Column(Integer, ForeignKey('pod_nodes.node_id'))
-    # parent_id = Column(Integer, ForeignKey('pod_nodes.node_id'), nullable=True)
-    owner_id = Column(Integer, ForeignKey('pod_user.user_id'), nullable=True)
-    data_label = Column(Unicode(1024), unique=False, nullable=False)
-    data_content = Column(Text(), unique=False, nullable=False, default='')
-    data_file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
-    data_file_mime_type = Column(Unicode(255),  unique=False, nullable=False, default='')
-    data_file_content = sqlao.deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
-
-    node_status = Column(Unicode(32), unique=False, nullable=False)
-    created_at = Column(DateTime, unique=False, nullable=False)
-    updated_at = Column(DateTime, unique=False, nullable=False)
-    is_deleted = Column(sqlat.Boolean, unique=False, nullable=False)
-    is_archived = Column(sqlat.Boolean, unique=False, nullable=False)
-    last_action = Column(Unicode(32), unique=False, nullable=False, default='')
-
-    workspace_id = Column(Integer, ForeignKey('pod_workspaces.workspace_id'), unique=False, nullable=True)
+    __tablename__ = 'content_revisions'
+
+    revision_id = Column(Integer, primary_key=True)
+    content_id = Column(Integer, ForeignKey('contents.content_id'))
+    owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True)
+    label = Column(Unicode(1024), unique=False, nullable=False)
+    description = Column(Text(), unique=False, nullable=False, default='')
+    file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
+    file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
+    file_content = deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
+
+    status = Column(Unicode(32), unique=False, nullable=False)
+    created = Column(DateTime, unique=False, nullable=False)
+    updated = Column(DateTime, unique=False, nullable=False)
+    is_deleted = Column(Boolean, unique=False, nullable=False)
+    is_archived = Column(Boolean, unique=False, nullable=False)
+    revision_type = Column(Unicode(32), unique=False, nullable=False, default='')
+
+    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
     workspace = relationship('Workspace', remote_side=[Workspace.workspace_id])
 
-    node = relationship('PBNode', remote_side=[PBNode.node_id], backref='revisions')
+    node = relationship('Content', remote_side=[Content.content_id], backref='revisions')
     owner = relationship('User', remote_side=[User.user_id])
-    # parent = relationship('PBNode', remote_side=[PBNode.node_id])
 
     def get_status(self):
-        return ContentStatus(self.node_status)
+        return ContentStatus(self.status)
 
     def get_last_action(self) -> ActionDescription:
-        return ActionDescription(self.last_action)
+        return ActionDescription(self.revision_type)
 
 
 class NodeTreeItem(object):
         This class implements a model that allow to simply represents the left-panel menu items
          This model is used by dbapi but is not directly related to sqlalchemy and database
     """
-    def __init__(self, node: PBNode, children: list('NodeTreeItem'), is_selected = False):
+    def __init__(self, node: Content, children: list('NodeTreeItem'), is_selected = False):
         self.node = node
         self.children = children
         self.is_selected = is_selected
-
-
-
-
-#####
-#
-# HACK - 2014-05-21 - D.A
-#
-# The following hack is a horrible piece of code that allow to map a raw SQL select to a mapped class
-#
-class DIRTY_GroupRightsOnNode(object):
-    def hasSomeAccess(self):
-        return self.rights >= Rights.READ_ACCESS
-
-    def hasReadAccess(self):
-        return self.rights & Rights.READ_ACCESS
-
-    def hasWriteAccess(self):
-        return self.rights & Rights.WRITE_ACCESS
-
-DIRTY_group_rights_on_node_query = Table('fake_table', metadata,
-    Column('group_id', Integer, primary_key=True),
-    Column('node_id', Integer, primary_key=True),
-
-    Column('display_name', Unicode(255)),
-    Column('personnal_group', Boolean),
-    Column('rights', Integer, primary_key=True)
-)
-
-DIRTY_UserDedicatedGroupRightOnNodeSqlQuery = """
-SELECT
-    COALESCE(NULLIF(pg.display_name, ''), pu.display_name) AS display_name,
-    pg.personnal_group,
-    pg.group_id,
-    :node_id AS node_id,
-    COALESCE(pgn.rights, 0) AS rights
-FROM
-    pod_group AS pg
-    LEFT JOIN
-        pod_group_node AS pgn
-    ON
-        pg.group_id=pgn.group_id
-        AND pgn.node_id=:node_id
-    LEFT JOIN
-        pod_user AS pu
-    ON
-        pu.user_id=-pg.group_id
-WHERE
-    pg.personnal_group='t'
-ORDER BY
-    display_name
-;"""
-
-DIRTY_RealGroupRightOnNodeSqlQuery = """
-SELECT
-    pg.display_name AS display_name,
-    pg.personnal_group,
-    pg.group_id,
-    :node_id AS node_id,
-    COALESCE(pgn.rights, 0) AS rights
-FROM
-    pod_group AS pg
-    LEFT JOIN
-        pod_group_node AS pgn
-    ON
-        pg.group_id=pgn.group_id
-        AND pgn.node_id=:node_id
-WHERE
-    pg.personnal_group!='t'
-ORDER BY
-    display_name
-;"""
-
-sqlao.mapper(DIRTY_GroupRightsOnNode, DIRTY_group_rights_on_node_query)
-

tracim/tracim/model/serializers.py

 from tracim.model.data import ContentRevisionRO
 from tracim.model.data import LinkItem
 from tracim.model.data import NodeTreeItem
-from tracim.model.data import PBNode
-from tracim.model.data import PBNodeType
+from tracim.model.data import Content
+from tracim.model.data import ContentType
 from tracim.model.data import RoleType
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
 from tracim.model import data as pmd
 from tracim.lib import CST
 
-def node_to_dict(node: pmd.PBNode, children_content, new_item_state):
-    """
-    DEPRECATED - TODO - REMOVE
-        children_content may be boolean or a list containing json values
-    """
-    url = tg.url('/document/', dict(node_id=node.node_id)) ## FIXME - 2014-05-27 - Make this more flexible
-
-    return dict(
-        id = node.node_id,
-        children = children_content,
-        text = node.data_label,
-        a_attr = { "href" : url },
-        li_attr = { "title": node.data_label },
-        type = node.node_type, # this property is understandable by jstree (through "types" plugin)
-        state = new_item_state,
-        node_status = node.getStatus().getId() # this is not jstree understandable data. This requires a JS 'success' callback
-    )
-
-
-def PBNodeForMenu(func):
-
-    def process_item(item: pmd.PBNode):
-        """ convert given item into a dictionnary """
-        return node_to_dict(item, item.getChildNb()>0, None)
-
-    def pre_serialize(*args, **kws):
-        initial_result = func(*args, **kws)
-        real_result = None
-
-        if isinstance(initial_result, list):
-            real_result = list()
-            for value_item in initial_result:
-                real_result.append(process_item(value_item))
-        else:
-            # We suppose here that we have an object only
-            real_result = process_item(initial_result)
-
-        return dict(d = real_result)
-
-    return pre_serialize
-
-
-def NodeTreeItemForMenu(func):
-    """ works with structure NodeTreeItem """
-    def process_item(structure_item: pmd.NodeTreeItem, current_node_id=None):
-        """ convert given item into a dictionnary """
-
-        item = structure_item.node
-        children = []
-
-        for child_item in structure_item.children:
-            children.append(process_item(child_item, current_node_id))
-
-        children_field_value = None
-        if len(children)>0:
-            children_field_value = children
-        elif item.getChildNb()>0:
-            children_field_value = True
-        else:
-            children_field_value = False
-
-        new_item_state = dict(
-            opened = item.getChildNb()<=0 or len(children)>0,
-            selected = current_node_id!=None and item.node_id==current_node_id,
-        )
-
-        return node_to_dict(item, children_field_value, new_item_state)
-
-    def pre_serialize(*args, **kws):
-        initial_result = func(*args, **kws)
-        real_result = None
-
-        current_node_id = None
-        if "current_node_id" in kws:
-            current_node_id = int(kws['current_node_id'])
-
-        if isinstance(initial_result, list):
-            real_result = list()
-            for value_item in initial_result:
-                real_result.append(process_item(value_item, current_node_id))
-        else:
-            # We suppose here that we have an object only
-            real_result = process_item(initial_result, current_node_id)
-
-        return dict(d = real_result)
-
-    return pre_serialize
-
 #############################################################"
 ##
 ## HERE COMES THE SERIALIZATION CLASSES
 @pod_serializer(ContentRevisionRO, CTX.FILE)
 def serialize_version_for_page_or_file(version: ContentRevisionRO, context: Context):
     return DictLikeClass(
-        id = version.version_id,
-        node_id = version.node_id,
-        label = version.data_label if version.data_label else version.data_file_name,
+        id = version.revision_id,
+        label = version.label if version.label else version.file_name,
         owner = context.toDict(version.owner),
-        created = version.created_at,
+        created = version.created,
         action = context.toDict(version.get_last_action())
     )
 
 
-@pod_serializer(PBNode, CTX.DEFAULT)
-def serialize_breadcrumb_item(content: PBNode, context: Context):
+@pod_serializer(Content, CTX.DEFAULT)
+def serialize_breadcrumb_item(content: Content, context: Context):
     return DictLikeClass(
-        id = content.node_id,
-        label = content.data_label,
-        folder = context.toDict(DictLikeClass(id = content.parent.node_id if content.parent else None)),
-        # folder = None if not content.parent else context.toDict(DictLikeClass(id = content.parent.node_id)),
+        id = content.content_id,
+        label = content.label,
+        folder = context.toDict(DictLikeClass(id = content.parent.content_id if content.parent else None)),
         workspace = context.toDict(content.workspace)
     )
 
 
-@pod_serializer(PBNode, CTX.MENU_API)
-def serialize_content_for_menu_api(content: PBNode, context: Context):
-    content_id = content.node_id
+@pod_serializer(Content, CTX.MENU_API)
+def serialize_content_for_menu_api(content: Content, context: Context):
+    content_id = content.content_id
     workspace_id = content.workspace_id
 
     result = DictLikeClass(
         id = CST.TREEVIEW_MENU.ID_TEMPLATE__FULL.format(workspace_id, content_id),
         children = True, # TODO: make this dynamic
-        text = content.data_label,
+        text = content.label,
         a_attr = { 'href' : tg.url('/workspaces/{}/folders/{}'.format(workspace_id, content_id)) },
-        li_attr = { 'title': content.data_label, 'class': 'tracim-tree-item-is-a-folder' },
-        type = content.node_type,
+        li_attr = { 'title': content.label, 'class': 'tracim-tree-item-is-a-folder' },
+        type = content.type,
         state = { 'opened': False, 'selected': False }
     )
     return result
 
 
-@pod_serializer(PBNode, CTX.FILES)
-@pod_serializer(PBNode, CTX.PAGES)
-def serialize_node_for_page_list(content: PBNode, context: Context):
+@pod_serializer(Content, CTX.FILES)
+@pod_serializer(Content, CTX.PAGES)
+def serialize_node_for_page_list(content: Content, context: Context):
 
-    if content.node_type==PBNodeType.Page:
+    if content.type==ContentType.Page:
         if not content.parent:
             folder = None
         else:
-            print('FOLDER PARENT IS', content.parent)
             folder = Context(CTX.DEFAULT).toDict(content.parent)
-        print('FOLDER IS', folder)
+
         result = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
+            id = content.content_id,
+            label = content.label,
             status = context.toDict(content.get_status()),
             folder = folder
         )
         return result
 
-    if content.node_type==PBNodeType.File:
+    if content.type==ContentType.File:
         result = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label if content.data_label else content.data_file_name,
+            id = content.content_id,
+            label = content.label if content.label else content.file_name,
             status = context.toDict(content.get_status()),
             folder = Context(CTX.DEFAULT).toDict(content.parent)
         )
 
     # TODO - DA - 2014-10-16 - THE FOLLOWING CODE SHOULD BE REMOVED
     #
-    # if content.node_type==PBNodeType.Folder:
+    # if content.type==ContentType.Folder:
     #     return DictLikeClass(
-    #         id = content.node_id,
-    #         label = content.data_label,
+    #         id = content.content_id,
+    #         label = content.label,
     #     )
 
-    raise NotImplementedError('node type / context not implemented: {} {}'. format(content.node_type, context.context_string))
+    raise NotImplementedError('node type / context not implemented: {} {}'. format(content.type, context.context_string))
 
 
-@pod_serializer(PBNode, CTX.PAGE)
-@pod_serializer(PBNode, CTX.FILE)
-def serialize_node_for_page(content: PBNode, context: Context):
-    if content.node_type in (PBNodeType.Page, PBNodeType.File) :
+@pod_serializer(Content, CTX.PAGE)
+@pod_serializer(Content, CTX.FILE)
+def serialize_node_for_page(content: Content, context: Context):
+    if content.type in (ContentType.Page, ContentType.File) :
         data_container = content
 
 
         # The following properties are overriden by revision values
         if content.revision_to_serialize>0:
             for revision in content.revisions:
-                if revision.version_id==content.revision_to_serialize:
+                if revision.revision_id==content.revision_to_serialize:
                     data_container = revision
                     break
 
         result = DictLikeClass(
-            id = content.node_id,
+            id = content.content_id,
             parent = context.toDict(content.parent),
             workspace = context.toDict(content.workspace),
-            type = content.node_type,
+            type = content.type,
 
-            content = data_container.data_content,
-            created = data_container.created_at,
-            label = data_container.data_label,
-            icon = PBNodeType.icon(content.node_type),
+            content = data_container.description,
+            created = data_container.created,
+            label = data_container.label,
+            icon = ContentType.icon(content.type),
             owner = context.toDict(data_container.owner),
             status = context.toDict(data_container.get_status()),
-            links = context.toDict(content.extract_links_from_content(data_container.data_content)),
-            revisions = context.toDict(sorted(content.revisions, key=lambda v: v.created_at, reverse=True)),
+            links = context.toDict(content.extract_links_from_content(data_container.description)),
+            revisions = context.toDict(sorted(content.revisions, key=lambda v: v.created, reverse=True)),
             selected_revision = 'latest' if content.revision_to_serialize<=0 else content.revision_to_serialize
         )
 
-        if content.node_type==PBNodeType.File:
-            result.label = content.data_label if content.data_label else content.data_file_name
+        if content.type==ContentType.File:
+            result.label = content.label if content.label else content.file_name
             result['file'] = DictLikeClass(
-                name = data_container.data_file_name,
-                size = len(data_container.data_file_content),
-                mimetype = data_container.data_file_mime_type)
+                name = data_container.file_name,
+                size = len(data_container.file_content),
+                mimetype = data_container.file_mimetype)
         return result
 
-    if content.node_type==PBNodeType.Folder:
+    if content.type==ContentType.Folder:
         value = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
+            id = content.content_id,
+            label = content.label,
         )
         return value
 
     raise NotImplementedError
 
 
-@pod_serializer(PBNode, CTX.THREAD)
-def serialize_node_for_page(item: PBNode, context: Context):
-    if item.node_type==PBNodeType.Thread:
+@pod_serializer(Content, CTX.THREAD)
+def serialize_node_for_page(item: Content, context: Context):
+    if item.type==ContentType.Thread:
         return DictLikeClass(
-            content = item.data_content,
-            created = item.created_at,
-            icon = PBNodeType.icon(item.node_type),
-            id = item.node_id,
-            label = item.data_label,
-            links = context.toDict(item.extract_links_from_content(item.data_content)),
+            content = item.description,
+            created = item.created,
+            icon = ContentType.icon(item.type),
+            id = item.content_id,
+            label = item.label,
+            links = context.toDict(item.extract_links_from_content(item.description)),
             owner = context.toDict(item.owner),
             parent = context.toDict(item.parent),
             selected_revision = 'latest',
             status = context.toDict(item.get_status()),
-            type = item.node_type,
+            type = item.type,
             workspace = context.toDict(item.workspace),
             comments = reversed(context.toDict(item.get_comments()))
         )
 
-    if item.node_type==PBNodeType.Comment:
+    if item.type==ContentType.Comment:
         return DictLikeClass(
-            content = item.data_content,
-            created = item.created_at,
-            icon = PBNodeType.icon(item.node_type),
-            id = item.node_id,
-            label = item.data_label,
+            content = item.description,
+            created = item.created,
+            icon = ContentType.icon(item.type),
+            id = item.content_id,
+            label = item.label,
             owner = context.toDict(item.owner),
             # REMOVE parent = context.toDict(item.parent),
-            type = item.node_type,
+            type = item.type,
         )
 
-    if item.node_type==PBNodeType.Folder:
+    if item.type==ContentType.Folder:
         return Context(CTX.DEFAULT).toDict(item)
     ### CODE BELOW IS REPLACED BY THE TWO LINES UP ^^
     # 2014-10-08 - IF YOU FIND THIS COMMENT, YOU CAn REMOVE THE CODE
     #
-    #if item.node_type==PBNodeType.Folder:
+    #if item.type==ContentType.Folder:
     #    value = DictLikeClass(
-    #        id = item.node_id,
-    #        label = item.data_label,
+    #        id = item.content_id,
+    #        label = item.label,
     #    )
     #    return value
 
     raise NotImplementedError
 
 
-@pod_serializer(PBNode, CTX.THREADS)
-def serialize_node_for_thread_list(content: PBNode, context: Context):
-    if content.node_type==PBNodeType.Thread:
+@pod_serializer(Content, CTX.THREADS)
+def serialize_node_for_thread_list(content: Content, context: Context):
+    if content.type==ContentType.Thread:
         return DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
+            id = content.content_id,
+            label = content.label,
             status = context.toDict(content.get_status()),
             folder = context.toDict(content.parent),
             comment_nb = len(content.get_comments())
         )
 
-    if content.node_type==PBNodeType.Folder:
+    if content.type==ContentType.Folder:
         return Context(CTX.DEFAULT).toDict(content)
 
     raise NotImplementedError
 
-@pod_serializer(PBNode, CTX.WORKSPACE)
-@pod_serializer(PBNode, CTX.FOLDERS)
-def serialize_content_for_workspace(content: PBNode, context: Context):
-    content_id = content.node_id
-    workspace_id = content.workspace_id
-
-    thread_nb_all  = content.get_child_nb(PBNodeType.Thread)
-    thread_nb_open = content.get_child_nb(PBNodeType.Thread)
-    file_nb_all  = content.get_child_nb(PBNodeType.File)
-    file_nb_open = content.get_child_nb(PBNodeType.File)
-    folder_nb_all  = content.get_child_nb(PBNodeType.Folder)
-    folder_nb_open = content.get_child_nb(PBNodeType.Folder)
-    page_nb_all  = content.get_child_nb(PBNodeType.Data)
-    page_nb_open = content.get_child_nb(PBNodeType.Data)
+@pod_serializer(Content, CTX.WORKSPACE)
+@pod_serializer(Content, CTX.FOLDERS)
+def serialize_content_for_workspace(content: Content, context: Context):
+    thread_nb_all  = content.get_child_nb(ContentType.Thread)
+    thread_nb_open = content.get_child_nb(ContentType.Thread)
+    file_nb_all  = content.get_child_nb(ContentType.File)
+    file_nb_open = content.get_child_nb(ContentType.File)
+    folder_nb_all  = content.get_child_nb(ContentType.Folder)
+    folder_nb_open = content.get_child_nb(ContentType.Folder)
+    page_nb_all  = content.get_child_nb(ContentType.Page)
+    page_nb_open = content.get_child_nb(ContentType.Page)
 
     content_nb_all = thread_nb_all +\
                      thread_nb_open +\
                      page_nb_open
 
 
-    if content.node_type==PBNodeType.Folder:
+    result = None
+    if content.type==ContentType.Folder:
         result = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
+            id = content.content_id,
+            label = content.label,
             thread_nb = DictLikeClass(
                 all = thread_nb_all,
                 open = thread_nb_open,
 
     return result
 
-@pod_serializer(PBNode, CTX.FOLDER)
-def serialize_content_for_workspace_and_folder(content: PBNode, context: Context):
-    content_id = content.node_id
-    workspace_id = content.workspace_id
-
-    thread_nb_all  = content.get_child_nb(PBNodeType.Thread)
-    thread_nb_open = content.get_child_nb(PBNodeType.Thread)
-    file_nb_all  = content.get_child_nb(PBNodeType.File)
-    file_nb_open = content.get_child_nb(PBNodeType.File)
-    folder_nb_all  = content.get_child_nb(PBNodeType.Folder)
-    folder_nb_open = content.get_child_nb(PBNodeType.Folder)
-    page_nb_all  = content.get_child_nb(PBNodeType.Data)
-    page_nb_open = content.get_child_nb(PBNodeType.Data)
+@pod_serializer(Content, CTX.FOLDER)
+def serialize_content_for_workspace_and_folder(content: Content, context: Context):
+    thread_nb_all  = content.get_child_nb(ContentType.Thread)
+    thread_nb_open = content.get_child_nb(ContentType.Thread)
+    file_nb_all  = content.get_child_nb(ContentType.File)
+    file_nb_open = content.get_child_nb(ContentType.File)
+    folder_nb_all  = content.get_child_nb(ContentType.Folder)
+    folder_nb_open = content.get_child_nb(ContentType.Folder)
+    page_nb_all  = content.get_child_nb(ContentType.Page)
+    page_nb_open = content.get_child_nb(ContentType.Page)
 
     content_nb_all = thread_nb_all +\
                      thread_nb_open +\
                      page_nb_open
 
 
-    if content.node_type==PBNodeType.Folder:
+    result = None
+    if content.type==ContentType.Folder:
         result = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
-            created = content.created_at,
+            id = content.content_id,
+            label = content.label,
+            created = content.created,
             workspace = context.toDict(content.workspace),
             allowed_content = DictLikeClass(content.properties['allowed_content']),
             selected_revision = 'latest',
             content_nb = DictLikeClass(all = content_nb_all)
         )
 
-    elif content.node_type==PBNodeType.Page:
+    elif content.type==ContentType.Page:
         result = DictLikeClass(
-            id = content.node_id,
-            label = content.data_label,
-            created = content.created_at,
+            id = content.content_id,
+            label = content.label,
+            created = content.created,
             workspace = context.toDict(content.workspace),
             owner = DictLikeClass(
-                id = content._oOwner.user_id,
-                name = content._oOwner.display_name
+                id = content.owner.user_id,
+                name = content.owner.get_display_name()
             ),
             status = DictLikeClass(id='', label=''), #FIXME - EXPORT DATA
         )
     result = DictLikeClass()
     result['id'] = user.user_id
     result['name'] = user.get_display_name()
-    result['email'] = user.email_address
+    result['email'] = user.email
     result['enabled'] = user.is_active
     result['profile'] = user.profile
     return result
     result = DictLikeClass()
     result['id'] = user.user_id
     result['name'] = user.get_display_name()
-    result['email'] = user.email_address
+    result['email'] = user.email
     result['roles'] = context.toDict(user.roles)
     result['enabled'] = user.is_active
     result['profile'] = user.profile
     result['role'] = role.role
     result['style'] = role.style
     result['role_description'] = role.role_as_label()
-    result['email'] = role.user.email_address
+    result['email'] = role.user.email
     return result
 
 
     result['label'] = role.role_as_label()
     result['style'] = RoleType(role.role).css_style
     result['workspace'] =  context.toDict(role.workspace)
-    # result['workspace_name'] = role.workspace.data_label
+    # result['workspace_name'] = role.workspace.label
 
     return result
 
 def serialize_workspace_default(workspace: Workspace, context: Context):
     result = DictLikeClass(
         id = workspace.workspace_id,
-        label = workspace.data_label
+        label = workspace.label
     )
     return result
 
     """
     result = DictLikeClass()
     result['id'] = workspace.workspace_id
-    result['name'] = workspace.data_label
+    result['name'] = workspace.label
 
     return result
 
 def serialize_workspace_in_list(workspace: pmd.Workspace, context: Context):
     result = DictLikeClass()
     result['id'] = workspace.workspace_id
-    result['label'] = workspace.data_label
-    result['description'] = workspace.data_comment
+    result['label'] = workspace.label
+    result['description'] = workspace.description
     result['member_nb'] = len(workspace.roles)
 
     #    roles = serializableObject.roles
 def serialize_workspace_complete(workspace: pmd.Workspace, context: Context):
     result = DictLikeClass()
     result['id'] = workspace.workspace_id
-    result['label'] = workspace.data_label
-    result['description'] = workspace.data_comment
-    result['created'] = workspace.created_at
+    result['label'] = workspace.label
+    result['description'] = workspace.description
+    result['created'] = workspace.created
     result['members'] = context.toDict(workspace.roles)
     result['member_nb'] = len(workspace.roles)
 
     result = DictLikeClass(
         id = CST.TREEVIEW_MENU.ID_TEMPLATE__WORKSPACE_ONLY.format(workspace.workspace_id),
         children = True, # TODO: make this dynamic
-        text = workspace.data_label,
+        text = workspace.label,
         a_attr = { 'href' : tg.url('/workspaces/{}'.format(workspace.workspace_id)) },
-        li_attr = { 'title': workspace.data_label, 'class': 'tracim-tree-item-is-a-workspace' },
+        li_attr = { 'title': workspace.label, 'class': 'tracim-tree-item-is-a-workspace' },
         type = 'workspace',
         state = { 'opened': False, 'selected': False }
     )
 
 @pod_serializer(NodeTreeItem, CTX.MENU_API_BUILD_FROM_TREE_ITEM)
 def serialize_node_tree_item_for_menu_api_tree(item: NodeTreeItem, context: Context):
-    if isinstance(item.node, PBNode):
+    if isinstance(item.node, Content):
         return DictLikeClass(
-            id=CST.TREEVIEW_MENU.ID_TEMPLATE__FULL.format(item.node.workspace_id, item.node.node_id),
+            id=CST.TREEVIEW_MENU.ID_TEMPLATE__FULL.format(item.node.workspace_id, item.node.content_id),
             children=True if len(item.children)<=0 else context.toDict(item.children),
-            text=item.node.data_label,
-            a_attr={'href': tg.url('/workspaces/{}/folders/{}'.format(item.node.workspace_id, item.node.node_id)) },
-            li_attr={'title': item.node.data_label, 'class': 'tracim-tree-item-is-a-folder'},
+            text=item.node.label,
+            a_attr={'href': tg.url('/workspaces/{}/folders/{}'.format(item.node.workspace_id, item.node.content_id)) },
+            li_attr={'title': item.node.label, 'class': 'tracim-tree-item-is-a-folder'},
             type='folder',
             state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
         )
         return DictLikeClass(
             id=CST.TREEVIEW_MENU.ID_TEMPLATE__WORKSPACE_ONLY.format(item.node.workspace_id),
             children=True if len(item.children)<=0 else context.toDict(item.children),
-            text=item.node.data_label,
+            text=item.node.label,
             a_attr={'href': tg.url('/workspaces/{}'.format(item.node.workspace_id))},
-            li_attr={'title': item.node.data_label, 'class': 'tracim-tree-item-is-a-workspace'},
+            li_attr={'title': item.node.label, 'class': 'tracim-tree-item-is-a-workspace'},
             type='workspace',
             state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
         )

tracim/tracim/public/assets/css/dashboard.css

 .pod-tree-item-is-a-folder > a { }
 
 
-.pod-less-visible { color: #999; }
+.tracim-less-visible { color: #999; }
 
-.pod-status-open { font-weight: bold; color: #759ac5; }
-.pod-status-closed-validated { font-weight: bold; color: #1fdb11;}
-.pod-status-closed-unvalidated { font-weight: bold; color: #F00;}
-.pod-status-closed-deprecated { font-weight: bold; color: #ea983d;}
-.pod-status-selected { background-color: #EEE; }
-.pod-panel-separator { border-width: 12px 0 0 0; }
+.tracim-status-open { font-weight: bold; color: #759ac5; }
+.tracim-status-closed-validated { font-weight: bold; color: #1fdb11;}
+.tracim-status-closed-unvalidated { font-weight: bold; color: #F00;}
+.tracim-status-closed-deprecated { font-weight: bold; color: #ea983d;}
+.tracim-status-selected { background-color: #EEE; }
+.tracim-panel-separator { border-width: 12px 0 0 0; }
 
-.pod-thread-item {}
-.pod-thread-item-content { margin-left: 12px; border-left: 8px solid #EEE; padding: 0 0.5em; }
+.tracim-thread-item {}
+.tracim-thread-item-content { margin-left: 12px; border-left: 8px solid #EEE; padding: 0 0.5em; }
 
+#tracim-footer-separator { margin-bottom: 30px; }
 .pod-footer {
     position: fixed;
     bottom: 0;
     width: 100%;
+    background-color: #F5F5F5;
+    border-top: 1px solid #CCC;
+    z-index: 1001;
 }
+.pod-footer p { margin: auto; }
 
 

tracim/tracim/templates/debug/iconset-tango.mak

     import sys
 
     icon_files = dict()
-    rootdir = './pod/public/assets/icons/'
+    rootdir = './tracim/public/assets/icons/'
     
     for root, subFolders, files in os.walk(rootdir):
         for foundFile in files:

tracim/tracim/templates/master_anonymous.mak

         <div class="container-fluid">
             ${self.main_menu()}
             ${self.content_wrapper()}
-            ${self.footer()}
+            <div id="tracim-footer-separator"></div>
         </div>
+        ${self.footer()}
 
         <script src="${tg.url('/assets/js/bootstrap.min.js')}"></script>
         ## HACK - D.A. - 2014-10-21
 <%def name="footer()">
     <div class="pod-footer footer hidden-tablet hidden-phone text-center">
         <p>
-            <a href="http://trac.im">${_('Create your own email-ready collaborative workspace on trac.im')}</a> &mdash;
+            <a href="http://trac.im">${_('Create your own collaborative workspace on trac.im')}</a> &mdash;
             copyright &copy; 2013 - ${h.current_year()} tracim project.
         </p>
     </div>

tracim/tracim/templates/master_authenticated.mak

         <div class="container-fluid">
             ${self.main_menu()}
             ${self.content_wrapper()}
-            ${self.footer()}
-        </div>
-
+            <div id="tracim-footer-separator"></div>
+        </div>
+        ${self.footer()}
+
         <script src="${tg.url('/assets/js/bootstrap.min.js')}"></script>
         ${h.tracker_js()|n}
     </body>
 <%def name="footer()">
     <div class="pod-footer footer hidden-tablet hidden-phone text-center">
         <p>
-            <a href="http://trac.im">${_('Create your own email-ready collaborative workspace on trac.im')}</a> &mdash;
+            <a href="http://trac.im">${_('Create your own collaborative workspace on trac.im')}</a> &mdash;
             copyright &copy; 2013 - ${h.current_year()} tracim project.
         </p>
     </div>
 ##                        </li>
                         <li class="dropdown">
                             <a href="#" class="dropdown-toggle" data-toggle="dropdown">
-                              ${request.identity['user'].display_name}
+                              ${TIM.ICO(16, 'categories/applications-system')} ${request.identity['user'].display_name}
                             </a>
                             <ul class="dropdown-menu pull-right">
                                 <li>

tracim/tracim/templates/pod.mak

 <%def name="ICO_URL(icon_size, icon_path)">${h.IconPath(icon_size, icon_path)|n}</%def>
 <%def name="ICO(icon_size, icon_path, title='')"><img src="${h.IconPath(icon_size, icon_path)|n}" alt="" title="${title}"/></%def>
+<%def name="ICO_TOOLTIP(icon_size, icon_path, title='')"><span rel="tooltip" data-toggle="tooltip" data-placement="bottom" title="${title}">${ICO(icon_size, icon_path, title)}</span></%def>
 <%def name="ICO_BADGED(icon_size, icon_path, title='', css_class='badge')"><span class="${css_class}" rel="tooltip" data-toggle="tooltip" data-placement="bottom" title="${title}">${ICO(icon_size, icon_path, title)}</span></%def>
 <%def name="ICO_FA_BADGED(fa_class='fa fa-flag', title='', css_style='')"><i style="${css_style}" class="${fa_class}" rel="tooltip" data-toggle="tooltip" data-placement="bottom" title="${title}"></i></%def>
 

tracim/tracim/templates/user_get_me.mak

                             ${_('My workspaces')}
                         </h3>
                         % if len(result.user.roles)<=0:
-                            ${WIDGETS.EMPTY_CONTENT(_('This user is not member of any workspace.'))}
+                            ${WIDGETS.EMPTY_CONTENT(_('You are not member of any workspace.'))}
                         % else:
                             <table class="table">
                                 % for role in result.user.roles:

tracim/tracim/templates/user_workspace_folder_file_get_one.mak

 </div>
 
 % if result.file.status.id!='open':
-    <p class="pod-less-visible">${_('<b>Note</b>: You need to change status in case you want to upload a new version')|n}</p>
-    <hr class="pod-panel-separator"/>
+    <p class="tracim-less-visible">${_('<b>Note</b>: You need to change status in case you want to upload a new version')|n}</p>
+    <hr class="tracim-panel-separator"/>
 % else:
     % if h.user_role(fake_api.current_user, result.file.workspace)<=1: # User must be a contributor to be allowed to upload files
-        <hr class="pod-panel-separator"/>
+        <hr class="tracim-panel-separator"/>
         ${WIDGETS.SECURED_SECTION_TITLE(fake_api.current_user, result.file.workspace, 'file-revisions', _('File revisions'))}
         <p>${_('This file contains {} revision(s)').format(sum(1 for revision in result.file.revisions if revision.action.id=='revision'))}</p>
     % else:
-        <hr class="pod-panel-separator"/>
+        <hr class="tracim-panel-separator"/>
         ${WIDGETS.SECURED_SECTION_TITLE(fake_api.current_user, result.file.workspace, 'file-revisions', _('File revisions'), 'new-file-revision', _('upload a new revision and/or comment...'))}
         <p>${_('This file contains {} revision(s)').format(sum(1 for revision in result.file.revisions if revision.action.id=='revision'))}</p>
         ${FORMS.NEW_FILE_REVISION_WITH_COMMENT_FORM('new-file-revision', result.file.workspace.id, result.file.parent.id, result.file.id)}
 <div>
     <table class="table table-striped table-hover">
         % for revid, revision in reversed(list(enumerate(reversed(result.file.revisions)))):
-            % if revision.action.id=='revision':
+            % if revision.action.id in ('creation', 'revision'):
                 ## INFO - D.A. - 2014-10-22
                 ## We do not show status update and other editions that are not revisions
                 ## (at least in this revision list table)
                     <% rev_download_url = tg.url('/workspaces/{}/folders/{}/files/{}/download?revision_id={}'.format(result.file.workspace.id, result.file.parent.id, result.file.id, revision.id)) %>
                     <td><a href="${rev_download_url}">${TIM.ICO(16, 'actions/go-bottom', _('Download this particular revision'))}</a></td>
                     <td>${h.date_time_in_long_format(revision.created, _('%Y-%m-%d at %H:%M'))}</td>
-                    <td>${TIM.ICO(16, revision.action.icon, revision.action.label)}</td>
+                    <td>${TIM.ICO_TOOLTIP(16, revision.action.icon, revision.action.label)}</td>
                     <td>
                         % if warning_or_not:
                             ${TIM.ICO(16, 'actions/go-previous')} <strong>${_('Revision r{}').format(result.file.selected_revision)}</strong>

tracim/tracim/templates/user_workspace_folder_get_one.mak

         ${TIM.ICO_BADGED(16, 'mimetypes/text-html', _('pages'))}
     % endif
 </p>
-<hr class="pod-panel-separator"/>
+<hr class="tracim-panel-separator"/>
 
 % if result.folder.allowed_content.folder:
     % if h.user_role(fake_api.current_user, result.folder.workspace)<=2: # User must be a content manager to be allowed to create folders

tracim/tracim/templates/user_workspace_folder_page_get_one.mak

     ${result.page.content|n}
 </div>
 
-<hr class="pod-panel-separator"/>
+<hr class="tracim-panel-separator"/>
 <div>
     <h4 id="associated-links" class="anchored-title" >${_('Links extracted from the page')}</h4>
     <div>
             </ul>
         % endif
     </div>
-    <hr/>
+    <hr class="tracim-panel-separator"/>
 
 
     <h4 id="associated-links" class="anchored-title" >${_('Page revisions')}</h4>

tracim/tracim/templates/user_workspace_folder_thread_get_one.mak

 
 % if h.user_role(fake_api.current_user, result.thread.workspace)<=1:
     ## READONLY USER
-    <hr class="pod-panel-separator"/>
+    <hr class="tracim-panel-separator"/>
 % else:
     % if result.thread.status.id!='open':
-        <p class="pod-less-visible">${_('<b>Note</b>: In case you\'d like to post a reply, you must first open again the thread')|n}</p>
-        <hr class="pod-panel-separator"/>
+        <p class="tracim-less-visible">${_('<b>Note</b>: In case you\'d like to post a reply, you must first open again the thread')|n}</p>
+        <hr class="tracim-panel-separator"/>
     % else:
-        <hr class="pod-panel-separator"/>
+        <hr class="tracim-panel-separator"/>
         <p>    
             ${WIDGETS.DATA_TARGET_BUTTON('new-comment', _('Post a reply...'))}
             ${FORMS.NEW_COMMENT_FORM_IN_THREAD('new-comment', result.thread.workspace.id, result.thread.parent.id, result.thread.id)}
 % endif 
 
 % for comment in result.thread.comments:
-    <div class="pod-thread-item">
+    <div class="tracim-thread-item">
         <h5 style="margin: 0;">
             <div class="pull-right text-right">
                 <div class="label" style="font-size: 10px; border: 1px solid #CCC; color: #777; ">
             </div>
    
             ${TIM.ICO(32, comment.icon)}
-            <span class="pod-less-visible">${_('<strong>{}</strong> wrote:').format(comment.owner.name)|n}</span>
+            <span class="tracim-less-visible">${_('<strong>{}</strong> wrote:').format(comment.owner.name)|n}</span>
         </h5>
-        <div class="pod-thread-item-content">
+        <div class="tracim-thread-item-content">
             <div>${comment.content|n}</div>
             <br/>
         </div>
 
 % endfor
 
-## <hr class="pod-panel-separator"/>
+## <hr class="tracim-panel-separator"/>
 ## <div>
 ##     <h4 id="associated-links" class="anchored-title" >${_('Links extracted from the thread')}</h4>
 ##     <div>

tracim/tracim/templates/user_workspace_get_one.mak

         % endfor
     % endif
 </p>
-<hr class="pod-panel-separator"/>
+<hr class="tracim-panel-separator"/>
 
 
 % if h.user_role(fake_api.current_user, result.workspace)<=2: # User must be a content manager to be allowed to create folders

tracim/tracim/tests/models/test_auth.py

     klass = model.User
     attrs = dict(
         user_name = "ignucius",
-        email_address = "ignucius@example.org"
+        email = "ignucius@example.org"
         )
 
     def test_obj_creation_username(self):
 
     def test_obj_creation_email(self):
         """The obj constructor must set the email right"""
-        eq_(self.obj.email_address, "ignucius@example.org")
+        eq_(self.obj.email, "ignucius@example.org")
 
     def test_no_permissions_by_default(self):
         """User objects should have no permission by default."""

tracim/tracim/websetup/bootstrap.py

         u = model.User()
         u.user_name = 'manager'
         u.display_name = 'Example manager'
-        u.email_address = 'manager@somedomain.com'
+        u.email = 'manager@somedomain.com'
         u.password = 'managepass'
     
         model.DBSession.add(u)
         u1 = model.User()
         u1.user_name = 'editor'
         u1.display_name = 'Example editor'
-        u1.email_address = 'editor@somedomain.com'
+        u1.email = 'editor@somedomain.com'
         u1.password = 'editpass'
     
         model.DBSession.add(u1)