Model integration into tracim v2 (uncomplete)

.gitignore

 # binary translation files
 *.mo
 
-# Virtualenv
-/venv/

tracim/__init__.py

 from pyramid.config import Configurator
 
-from config import RequestWithCFG
+from tracim.config import RequestWithCFG
 
 
 def main(global_config, **settings):

tracim/exceptions.py

+# -*- coding: utf-8 -*-
+
+
+class TracimError(Exception):
+    pass
+
+class TracimException(Exception):
+    pass
+
+class RunTimeError(TracimError):
+    pass
+
+
+class ContentRevisionUpdateError(RuntimeError):
+    pass
+
+
+class ContentRevisionDeleteError(ContentRevisionUpdateError):
+    pass
+
+
+class ConfigurationError(TracimError):
+    pass
+
+
+class AlreadyExistError(TracimError):
+    pass
+
+
+class CommandError(TracimError):
+    pass
+
+
+class CommandAbortedError(CommandError):
+    pass
+
+class DaemonException(TracimException):
+    pass
+
+
+class AlreadyRunningDaemon(DaemonException):
+    pass
+
+
+class CalendarException(TracimException):
+    pass
+
+
+class UnknownCalendarType(CalendarException):
+    pass
+
+
+class NotFound(TracimException):
+    pass
+
+class SameValueError(ValueError):
+    pass

tracim/models/__init__.py

 from sqlalchemy import engine_from_config
+from sqlalchemy.event import listen
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.orm import configure_mappers
 import zope.sqlalchemy
-
+from .meta import DeclarativeBase
+from .revision_protection import prevent_content_revision_delete
 # import or define all models here to ensure they are attached to the
 # Base.metadata prior to any initialization routines
 from .mymodel import MyModel  # flake8: noqa
+from .auth import User, Group, Permission
+from .data import Content, ContentRevisionRO
 
 # run configure_mappers after defining all of the models to ensure
 # all relationships can be setup
     dbsession = session_factory()
     zope.sqlalchemy.register(
         dbsession, transaction_manager=transaction_manager)
+    listen(dbsession, 'before_flush', prevent_content_revision_delete)
     return dbsession
 
 

tracim/models/auth.py

 from sqlalchemy.types import Integer
 from sqlalchemy.types import Unicode
 
-from tracim.lib.utils import lazy_ugettext as l_
-from tracim.model import DBSession
-from tracim.model import DeclarativeBase
-from tracim.model import metadata
+from tracim.translation import fake_translator as l_
+from tracim.models.meta import DeclarativeBase
+from tracim.models.meta import metadata
 if TYPE_CHECKING:
-    from tracim.model.data import Workspace
-
+    from tracim.models.data import Workspace
+    from tracim.models.data import UserRoleInWorkspace
 __all__ = ['User', 'Group', 'Permission']
 
 # This is the association table for the many-to-many relationship between
         return self.group_name
 
     @classmethod
-    def by_group_name(cls, group_name):
+    def by_group_name(cls, group_name, dbsession):
         """Return the user object whose email address is ``email``."""
-        return DBSession.query(cls).filter_by(group_name=group_name).first()
+        return dbsession.query(cls).filter_by(group_name=group_name).first()
 
 
 class Profile(object):
             profile_id = max(group.group_id for group in self.groups)
         return Profile(profile_id)
 
-    @property
-    def calendar_url(self) -> str:
-        # TODO - 20160531 - Bastien: Cyclic import if import in top of file
-        from tracim.lib.calendar import CalendarManager
-        calendar_manager = CalendarManager(None)
-
-        return calendar_manager.get_user_calendar_url(self.user_id)
+    # TODO - G-M - 27-03-2018 - Check about calendar code
+    # @property
+    # def calendar_url(self) -> str:
+    #     # TODO - 20160531 - Bastien: Cyclic import if import in top of file
+    #     from tracim.lib.calendar import CalendarManager
+    #     calendar_manager = CalendarManager(None)
+    #
+    #     return calendar_manager.get_user_calendar_url(self.user_id)
 
     @classmethod
-    def by_email_address(cls, email):
+    def by_email_address(cls, email, dbsession):
         """Return the user object whose email address is ``email``."""
-        return DBSession.query(cls).filter_by(email=email).first()
+        return dbsession.query(cls).filter_by(email=email).first()
 
     @classmethod
-    def by_user_name(cls, username):
+    def by_user_name(cls, username, dbsession):
         """Return the user object whose user name is ``username``."""
-        return DBSession.query(cls).filter_by(email=username).first()
+        return dbsession.query(cls).filter_by(email=username).first()
 
     @classmethod
     def _hash_password(cls, cleartext_password: str) -> str:
             if role.workspace == workspace:
                 return role.role
 
-        from tracim.model.data import UserRoleInWorkspace
         return UserRoleInWorkspace.NOT_APPLICABLE
 
     def get_active_roles(self) -> ['UserRoleInWorkspace']:
                 roles.append(role)
         return roles
 
-    def ensure_auth_token(self) -> None:
+    def ensure_auth_token(self, validity_seconds, dbsession) -> None:
         """
         Create auth_token if None, regenerate auth_token if too much old.
 
         auth_token validity is set in
         :return:
         """
-        from tracim.config.app_cfg import CFG
-        validity_seconds = CFG.get_instance().USER_AUTH_TOKEN_VALIDITY
 
         if not self.auth_token or not self.auth_token_created:
             self.auth_token = str(uuid.uuid4())
             self.auth_token_created = datetime.utcnow()
-            DBSession.flush()
+            dbsession.flush()
             return
 
         now_seconds = time.mktime(datetime.utcnow().timetuple())

tracim/models/data.py

 import os
 from datetime import datetime
 
-import tg
 from babel.dates import format_timedelta
 from bs4 import BeautifulSoup
 from sqlalchemy import Column, inspect, Index
 from depot.fields.upload import UploadedFile
 from depot.io.utils import FileIntent
 
-from tracim.lib.utils import lazy_ugettext as l_
-from tracim.lib.exception import ContentRevisionUpdateError
-from tracim.model import DeclarativeBase, RevisionsIntegrity
-from tracim.model.auth import User
+from tracim.translation import fake_translator as l_
+from tracim.exceptions import ContentRevisionUpdateError
+from tracim.models.meta import DeclarativeBase
+from tracim.models.auth import User
 
 DEFAULT_PROPERTIES = dict(
     allowed_content=dict(
 
         return contents
 
-    @property
-    def calendar_url(self) -> str:
-        # TODO - 20160531 - Bastien: Cyclic import if import in top of file
-        from tracim.lib.calendar import CalendarManager
-        calendar_manager = CalendarManager(None)
-
-        return calendar_manager.get_workspace_calendar_url(self.workspace_id)
+    # TODO - G-M - 27-03-2018 - Check about calendar code
+    # @property
+    # def calendar_url(self) -> str:
+    #     # TODO - 20160531 - Bastien: Cyclic import if import in top of file
+    #     from tracim.lib.calendar import CalendarManager
+    #     calendar_manager = CalendarManager(None)
+    #
+    #     return calendar_manager.get_workspace_calendar_url(self.workspace_id)
 
     def get_user_role(self, user: User) -> int:
         for role in user.roles:
         # TODO - G.M - 15-03-2018 - Choose only correct Content-type for origin
         # Only content who can be copied need this
         if item.type == ContentType.Any:
+            properties = item.properties
             if 'origin' in properties.keys():
                 return True
         raise NotImplementedError

tracim/models/meta.py

 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.schema import MetaData
+from sqlalchemy import inspect
+
+from tracim.exceptions import ContentRevisionUpdateError
 
 # Recommended naming convention used by Alembic, as various different database
 # providers will autogenerate vastly different names making migrations more
 }
 
 metadata = MetaData(naming_convention=NAMING_CONVENTION)
-Base = declarative_base(metadata=metadata)
+DeclarativeBase = declarative_base(metadata=metadata)

tracim/models/mymodel.py

     Text,
 )
 
-from .meta import Base
+from .meta import DeclarativeBase
 
 
-class MyModel(Base):
+class MyModel(DeclarativeBase):
     __tablename__ = 'models'
     id = Column(Integer, primary_key=True)
     name = Column(Text)

tracim/models/organisational.py

-from tracim.model import User
-from tracim.model.data import UserRoleInWorkspace
+from tracim.models import User
+from tracim.models.data import UserRoleInWorkspace
 
 
 CALENDAR_PERMISSION_READ = 'r'

tracim/models/revision_protection.py

+from sqlalchemy.orm import Session
+from sqlalchemy import inspect
+from sqlalchemy.orm.unitofwork import UOWTransaction
+from transaction import TransactionManager
+from contextlib import contextmanager
+
+from tracim.exceptions import ContentRevisionDeleteError
+from tracim.exceptions import ContentRevisionUpdateError
+from tracim.exceptions import SameValueError
+
+from .data import ContentRevisionRO
+from .data import Content
+from .meta import DeclarativeBase
+
+
+def prevent_content_revision_delete(
+        session: Session,
+        flush_context: UOWTransaction,
+        instances: [DeclarativeBase]
+) -> None:
+    for instance in session.deleted:
+        if isinstance(instance, ContentRevisionRO) \
+                and instance.revision_id is not None:
+            raise ContentRevisionDeleteError(
+                "ContentRevision is not deletable. " +
+                "You must make a new revision with" +
+                "is_deleted set to True. Look at " +
+                "tracim.model.new_revision context " +
+                "manager to make a new revision"
+            )
+
+
+class RevisionsIntegrity(object):
+    """
+    Simple static used class to manage a list with list of ContentRevisionRO
+    who are allowed to be updated.
+
+    When modify an already existing (understood have an identity in databse)
+    ContentRevisionRO, if it's not in RevisionsIntegrity._updatable_revisions
+    list, a ContentRevisionUpdateError thrown.
+
+    This class is used by tracim.model.new_revision context manager.
+    """
+    _updatable_revisions = []
+
+    @classmethod
+    def add_to_updatable(cls, revision: 'ContentRevisionRO') -> None:
+        if inspect(revision).has_identity:
+            raise ContentRevisionUpdateError("ContentRevision is not updatable. %s already have identity." % revision)  # nopep8
+
+        if revision not in cls._updatable_revisions:
+            cls._updatable_revisions.append(revision)
+
+    @classmethod
+    def remove_from_updatable(cls, revision: 'ContentRevisionRO') -> None:
+        if revision in cls._updatable_revisions:
+            cls._updatable_revisions.remove(revision)
+
+    @classmethod
+    def is_updatable(cls, revision: 'ContentRevisionRO') -> bool:
+        return revision in cls._updatable_revisions
+
+
+@contextmanager
+def new_revision(
+        dbsession: Session,
+        tm: TransactionManager,
+        content: Content,
+        force_create_new_revision: bool=False,
+) -> Content:
+    """
+    Prepare context to update a Content. It will add a new updatable revision
+    to the content.
+    :param dbsession: Database session
+    :param tm: TransactionManager
+    :param content: Content instance to update
+    :param force_create_new_revision: Decide if new_rev should or should not
+    be forced.
+    :return:
+    """
+    with dbsession.no_autoflush:
+        try:
+            if force_create_new_revision \
+                    or inspect(content.revision).has_identity:
+                content.new_revision()
+            RevisionsIntegrity.add_to_updatable(content.revision)
+            yield content
+        except SameValueError or ValueError as e:
+            # INFO - 20-03-2018 - renew transaction when error happened
+            # This avoid bad session data like new "temporary" revision
+            # to be add when problem happen.
+            tm.abort()
+            tm.begin()
+            raise e
+        finally:
+            RevisionsIntegrity.remove_from_updatable(content.revision)

tracim/routes.py

 def includeme(config):
     config.add_static_view('static', 'static', cache_max_age=3600)
     config.add_route('home', '/')
+    config.add_route('test_config', '/test_config')
+    config.add_route('test_model', '/test_model')

tracim/scripts/initializedb.py

 
 from pyramid.scripts.common import parse_vars
 
-from ..models.meta import Base
+from ..models.meta import DeclarativeBase
 from ..models import (
     get_engine,
     get_session_factory,
     settings = get_appsettings(config_uri, options=options)
 
     engine = get_engine(settings)
-    Base.metadata.create_all(engine)
+    DeclarativeBase.metadata.create_all(engine)
 
     session_factory = get_session_factory(engine)
 

tracim/templates/mytemplate.jinja2

 {% block content %}
 <div class="content">
   <h1><span class="font-semi-bold">Pyramid</span> <span class="smaller">Alchemy project</span></h1>
-  <p class="lead">Welcome to <span class="font-normal">tracim</span>, a&nbsp;Pyramid application generated&nbsp;by<br><span class="font-normal">Cookiecutter</span>.</p>
+  <p class="lead">Welcome to <span class="font-normal">{{ project }}</span>, a&nbsp;Pyramid application generated&nbsp;by<br><span class="font-normal">Cookiecutter</span>.</p>
 </div>
 {% endblock content %}

tracim/translation.py

+
+# TODO - G.M - 27-03-2018 - Reconnect true internationalization
+def fake_translator(text: str):
+    return text

tracim/views/default.py

 from sqlalchemy.exc import DBAPIError
 
 from ..models import MyModel
+from ..models import Content
+
+
+@view_config(route_name='test_config', renderer='../templates/mytemplate.jinja2')
+def test_config(request):
+    try:
+        project = request.config().WEBSITE_TITLE
+    except Exception as e:
+        return Response(e, content_type='text/plain', status=500)
+    return {'project': project}
+
+@view_config(route_name='test_model', renderer='../templates/mytemplate.jinja2')
+def test_model(request):
+    try:
+        # project = request.dbsession.query(MyModel)
+    except Exception as e:
+        return Response(e, content_type='text/plain', status=500)
+    return {'project': project}
 
 
 @view_config(route_name='home', renderer='../templates/mytemplate.jinja2')
 def my_view(request):
-    request.config()
     try:
         query = request.dbsession.query(MyModel)
         one = query.filter(MyModel.name == 'one').first()