Changeset - 92b4b392b0df
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Søren Løvborg - 9 years ago 2016-07-15 15:16:07
sorenl@unity3d.com
db: remove redundant unique constraints from primary keys

Primary keys are always unique, both in the SQL standard and in SQLite,
MySQL and PostgreSQL.

Setting unique=True cases SQLAlchemy to explicitly add additional,
redundant UNIQUE indexes to the columns, which is at best needless
metadata overhead, and at worst causes the database engine to waste
time maintaining an extra index that serves no purpose.
1 file changed with 31 insertions and 31 deletions:
kallithea/model/db.py
31
31
0 comments (0 inline, 0 general)
kallithea/model/db.py
➞
Show inline comments
 
@@ -158,49 +158,49 @@ class BaseModel(object):
 
        return '<DB:%s>' % (self.__class__.__name__)
 

			




	
	
	
		
 

			




	
	
	
		
 
_table_args_default_dict = {'extend_existing': True,

			




	
	
	
		
 
                            'mysql_engine': 'InnoDB',

			




	
	
	
		
 
                            'mysql_charset': 'utf8',

			




	
	
	
		
 
                            'sqlite_autoincrement': True,

			




	
	
	
		
 
                           }

			




	
	
	
		
 

			




	
	
	
		
 
class Setting(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = DB_PREFIX + 'settings'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    SETTINGS_TYPES = {

			




	
	
	
		
 
        'str': safe_str,

			




	
	
	
		
 
        'int': safe_int,

			




	
	
	
		
 
        'unicode': safe_unicode,

			




	
	
	
		
 
        'bool': str2bool,

			




	
	
	
		
 
        'list': functools.partial(aslist, sep=',')

			




	
	
	
		
 
    }

			




	
	
	
		
 
    DEFAULT_UPDATE_URL = ''

			




	
	
	
		
 

			




	
	
	
		
 
    app_settings_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    app_settings_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    app_settings_name = Column(String(255), nullable=False, unique=True)

			




	
	
	
		
 
    _app_settings_value = Column("app_settings_value", Unicode(4096), nullable=False)

			




	
	
	
		
 
    _app_settings_type = Column("app_settings_type", String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, key='', val='', type='unicode'):

			




	
	
	
		
 
        self.app_settings_name = key

			




	
	
	
		
 
        self.app_settings_value = val

			




	
	
	
		
 
        self.app_settings_type = type

			




	
	
	
		
 

			




	
	
	
		
 
    @validates('_app_settings_value')

			




	
	
	
		
 
    def validate_settings_value(self, key, val):

			




	
	
	
		
 
        assert type(val) == unicode

			




	
	
	
		
 
        return val

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def app_settings_value(self):

			




	
	
	
		
 
        v = self._app_settings_value

			




	
	
	
		
 
        _type = self.app_settings_type

			




	
	
	
		
 
        converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']

			




	
	
	
		
 
        return converter(v)

			




	
	
	
		
 

			




	
	
	
		
 
    @app_settings_value.setter

			




	
	
	
		
 
    def app_settings_value(self, val):

			




	
	
	
		
 
        """

			




	
	
		
 
@@ -323,49 +323,49 @@ class Setting(Base, BaseModel):

			




	
	
	
		
 
            'kallithea_version': kallithea.__version__,

			




	
	
	
		
 
            'git_version': safe_unicode(check_git_version()),

			




	
	
	
		
 
            'git_path': kallithea.CONFIG.get('git_path')

			




	
	
	
		
 
        }

			




	
	
	
		
 
        return info

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Ui(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = DB_PREFIX + 'ui'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        # FIXME: ui_key as key is wrong and should be removed when the corresponding

			




	
	
	
		
 
        # Ui.get_by_key has been replaced by the composite key

			




	
	
	
		
 
        UniqueConstraint('ui_key'),

			




	
	
	
		
 
        UniqueConstraint('ui_section', 'ui_key'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    HOOK_UPDATE = 'changegroup.update'

			




	
	
	
		
 
    HOOK_REPO_SIZE = 'changegroup.repo_size'

			




	
	
	
		
 
    HOOK_PUSH = 'changegroup.push_logger'

			




	
	
	
		
 
    HOOK_PRE_PUSH = 'prechangegroup.pre_push'

			




	
	
	
		
 
    HOOK_PULL = 'outgoing.pull_logger'

			




	
	
	
		
 
    HOOK_PRE_PULL = 'preoutgoing.pre_pull'

			




	
	
	
		
 

			




	
	
	
		
 
    ui_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    ui_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    ui_section = Column(String(255), nullable=False)

			




	
	
	
		
 
    ui_key = Column(String(255), nullable=False)

			




	
	
	
		
 
    ui_value = Column(String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    ui_active = Column(Boolean(), nullable=False, default=True)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, section, key):

			




	
	
	
		
 
        """ Return specified Ui object, or None if not found. """

			




	
	
	
		
 
        return cls.query().filter_by(ui_section=section, ui_key=key).scalar()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_or_create(cls, section, key):

			




	
	
	
		
 
        """ Return specified Ui object, creating it if necessary. """

			




	
	
	
		
 
        setting = cls.get_by_key(section, key)

			




	
	
	
		
 
        if setting is None:

			




	
	
	
		
 
            setting = cls(ui_section=section, ui_key=key)

			




	
	
	
		
 
            Session().add(setting)

			




	
	
	
		
 
        return setting

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_builtin_hooks(cls):

			




	
	
	
		
 
        q = cls.query()

			




	
	
	
		
 
        q = q.filter(cls.ui_key.in_([cls.HOOK_UPDATE, cls.HOOK_REPO_SIZE,

			




	
	
	
		
 
                                     cls.HOOK_PUSH, cls.HOOK_PRE_PUSH,

			




	
	
		
 
@@ -387,49 +387,49 @@ class Ui(Base, BaseModel):

			




	
	
	
		
 
        return cls.get_by_key('paths', '/').ui_value

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create_or_update_hook(cls, key, val):

			




	
	
	
		
 
        new_ui = cls.get_or_create('hooks', key)

			




	
	
	
		
 
        new_ui.ui_active = True

			




	
	
	
		
 
        new_ui.ui_value = val

			




	
	
	
		
 

			




	
	
	
		
 
    def __repr__(self):

			




	
	
	
		
 
        return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,

			




	
	
	
		
 
                                    self.ui_key, self.ui_value)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class User(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('u_username_idx', 'username'),

			




	
	
	
		
 
        Index('u_email_idx', 'email'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    DEFAULT_USER = 'default'

			




	
	
	
		
 
    DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'

			




	
	
	
		
 

			




	
	
	
		
 
    user_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    username = Column(String(255), nullable=False, unique=True)

			




	
	
	
		
 
    password = Column(String(255), nullable=False)

			




	
	
	
		
 
    active = Column(Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    admin = Column(Boolean(), nullable=False, default=False)

			




	
	
	
		
 
    name = Column("firstname", Unicode(255), nullable=False)

			




	
	
	
		
 
    lastname = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    _email = Column("email", String(255), nullable=True, unique=True) # FIXME: not nullable?

			




	
	
	
		
 
    last_login = Column(DateTime(timezone=False), nullable=True)

			




	
	
	
		
 
    extern_type = Column(String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    extern_name = Column(String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    api_key = Column(String(255), nullable=False)

			




	
	
	
		
 
    inherit_default_permissions = Column(Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data # FIXME: not nullable?

			




	
	
	
		
 

			




	
	
	
		
 
    user_log = relationship('UserLog')

			




	
	
	
		
 
    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

			




	
	
	
		
 

			




	
	
	
		
 
    repositories = relationship('Repository')

			




	
	
	
		
 
    repo_groups = relationship('RepoGroup')

			




	
	
	
		
 
    user_groups = relationship('UserGroup')

			




	
	
	
		
 
    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

			




	
	
	
		
 
    followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')

			




	
	
	
		
 

			




	
	
		
 
@@ -690,159 +690,159 @@ class User(Base, BaseModel):

			




	
	
	
		
 
                ip_addresses=user.ip_addresses

			




	
	
	
		
 
                ))

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
            full_name=self.full_name,

			




	
	
	
		
 
            full_name_or_username=self.full_name_or_username,

			




	
	
	
		
 
            short_contact=self.short_contact,

			




	
	
	
		
 
            full_contact=self.full_contact

			




	
	
	
		
 
        )

			




	
	
	
		
 
        data.update(self.get_api_data())

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserApiKeys(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_api_keys'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('uak_api_key_idx', 'api_key'),

			




	
	
	
		
 
        Index('uak_api_key_expires_idx', 'api_key', 'expires'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    user_api_key_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_api_key_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    api_key = Column(String(255), nullable=False, unique=True)

			




	
	
	
		
 
    description = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    expires = Column(Float(53), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def expired(self):

			




	
	
	
		
 
        if self.expires == -1:

			




	
	
	
		
 
            return False

			




	
	
	
		
 
        return time.time() > self.expires

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserEmailMap(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_email_map'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('uem_email_idx', 'email'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    email_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    email_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    _email = Column("email", String(255), nullable=False, unique=True)

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @validates('_email')

			




	
	
	
		
 
    def validate_email(self, key, email):

			




	
	
	
		
 
        # check if this email is not main one

			




	
	
	
		
 
        main_email = Session().query(User).filter(User.email == email).scalar()

			




	
	
	
		
 
        if main_email is not None:

			




	
	
	
		
 
            raise AttributeError('email %s is present is user table' % email)

			




	
	
	
		
 
        return email

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def email(self):

			




	
	
	
		
 
        return self._email

			




	
	
	
		
 

			




	
	
	
		
 
    @email.setter

			




	
	
	
		
 
    def email(self, val):

			




	
	
	
		
 
        self._email = val.lower() if val else None

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserIpMap(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_ip_map'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'ip_addr'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    ip_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    ip_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    ip_addr = Column(String(255), nullable=False)

			




	
	
	
		
 
    active = Column(Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _get_ip_range(cls, ip_addr):

			




	
	
	
		
 
        from kallithea.lib import ipaddr

			




	
	
	
		
 
        net = ipaddr.IPNetwork(address=ip_addr)

			




	
	
	
		
 
        return [str(net.network), str(net.broadcast)]

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        return dict(

			




	
	
	
		
 
          ip_addr=self.ip_addr,

			




	
	
	
		
 
          ip_range=self._get_ip_range(self.ip_addr)

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,

			




	
	
	
		
 
                                            self.user_id, self.ip_addr)

			




	
	
	
		
 

			




	
	
	
		
 
class UserLog(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_logs'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_log_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_log_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True)

			




	
	
	
		
 
    username = Column(String(255), nullable=False)

			




	
	
	
		
 
    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

			




	
	
	
		
 
    repository_name = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    user_ip = Column(String(255), nullable=True)

			




	
	
	
		
 
    action = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    action_date = Column(DateTime(timezone=False), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,

			




	
	
	
		
 
                                      self.repository_name,

			




	
	
	
		
 
                                      self.action)

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def action_as_day(self):

			




	
	
	
		
 
        return datetime.date(*self.action_date.timetuple()[:3])

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    repository = relationship('Repository', cascade='')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroup(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_groups'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_name = Column(Unicode(255), nullable=False, unique=True)

			




	
	
	
		
 
    user_group_description = Column(Unicode(10000), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    users_group_active = Column(Boolean(), nullable=False)

			




	
	
	
		
 
    inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data # FIXME: not nullable?

			




	
	
	
		
 

			




	
	
	
		
 
    members = relationship('UserGroupMember', cascade="all, delete-orphan")

			




	
	
	
		
 
    users_group_to_perm = relationship('UserGroupToPerm', cascade='all')

			




	
	
	
		
 
    users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

			




	
	
	
		
 
    users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

			




	
	
	
		
 
    user_user_group_to_perm = relationship('UserUserGroupToPerm ', cascade='all')

			




	
	
	
		
 
    user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def group_data(self):

			




	
	
	
		
 
        if not self._group_data:

			




	
	
	
		
 
            return {}

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            return json.loads(self._group_data)

			




	
	
		
 
@@ -889,113 +889,113 @@ class UserGroup(Base, BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
            users_group_id=user_group.users_group_id,

			




	
	
	
		
 
            group_name=user_group.users_group_name,

			




	
	
	
		
 
            group_description=user_group.user_group_description,

			




	
	
	
		
 
            active=user_group.users_group_active,

			




	
	
	
		
 
            owner=user_group.user.username,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        if with_members:

			




	
	
	
		
 
            members = []

			




	
	
	
		
 
            for user in user_group.members:

			




	
	
	
		
 
                user = user.user

			




	
	
	
		
 
                members.append(user.get_api_data())

			




	
	
	
		
 
            data['members'] = members

			




	
	
	
		
 

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupMember(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_groups_members'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_member_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    users_group_member_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    users_group = relationship('UserGroup')

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, gr_id='', u_id=''):

			




	
	
	
		
 
        self.users_group_id = gr_id

			




	
	
	
		
 
        self.user_id = u_id

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class RepositoryField(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'repositories_fields'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('repository_id', 'field_key'),  # no-multi field

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields

			




	
	
	
		
 

			




	
	
	
		
 
    repo_field_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    repo_field_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    field_key = Column(String(250), nullable=False)

			




	
	
	
		
 
    field_label = Column(String(1024), nullable=False)

			




	
	
	
		
 
    field_value = Column(String(10000), nullable=False)

			




	
	
	
		
 
    field_desc = Column(String(1024), nullable=False)

			




	
	
	
		
 
    field_type = Column(String(255), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    repository = relationship('Repository')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def field_key_prefixed(self):

			




	
	
	
		
 
        return 'ex_%s' % self.field_key

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def un_prefix_key(cls, key):

			




	
	
	
		
 
        if key.startswith(cls.PREFIX):

			




	
	
	
		
 
            return key[len(cls.PREFIX):]

			




	
	
	
		
 
        return key

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key_name(cls, key, repo):

			




	
	
	
		
 
        row = cls.query() \

			




	
	
	
		
 
                .filter(cls.repository == repo) \

			




	
	
	
		
 
                .filter(cls.field_key == key).scalar()

			




	
	
	
		
 
        return row

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Repository(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'repositories'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('r_repo_name_idx', 'repo_name'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

			




	
	
	
		
 
    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

			




	
	
	
		
 

			




	
	
	
		
 
    STATE_CREATED = 'repo_state_created'

			




	
	
	
		
 
    STATE_PENDING = 'repo_state_pending'

			




	
	
	
		
 
    STATE_ERROR = 'repo_state_error'

			




	
	
	
		
 

			




	
	
	
		
 
    repo_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    repo_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    repo_name = Column(Unicode(255), nullable=False, unique=True)

			




	
	
	
		
 
    repo_state = Column(String(255), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    clone_uri = Column(String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    repo_type = Column(String(255), nullable=False)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    private = Column(Boolean(), nullable=False)

			




	
	
	
		
 
    enable_statistics = Column("statistics", Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    enable_downloads = Column("downloads", Boolean(), nullable=False, default=True)

			




	
	
	
		
 
    description = Column(Unicode(10000), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    _landing_revision = Column("landing_revision", String(255), nullable=False)

			




	
	
	
		
 
    enable_locking = Column(Boolean(), nullable=False, default=False)

			




	
	
	
		
 
    _locked = Column("locked", String(255), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 
    _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data # FIXME: not nullable?

			




	
	
	
		
 

			




	
	
	
		
 
    fork_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

			




	
	
	
		
 
    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    fork = relationship('Repository', remote_side=repo_id)

			




	
	
	
		
 
    group = relationship('RepoGroup')

			




	
	
	
		
 
    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')

			




	
	
		
 
@@ -1471,49 +1471,49 @@ class Repository(Base, BaseModel):

			




	
	
	
		
 
        backend = get_backend(alias)

			




	
	
	
		
 

			




	
	
	
		
 
        if alias == 'hg':

			




	
	
	
		
 
            repo = backend(repo_full_path, create=False,

			




	
	
	
		
 
                           baseui=self._ui)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            repo = backend(repo_full_path, create=False)

			




	
	
	
		
 

			




	
	
	
		
 
        return repo

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        return dict(landing_rev = self.landing_rev)

			




	
	
	
		
 

			




	
	
	
		
 
class RepoGroup(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'groups'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('group_name', 'group_parent_id'),

			




	
	
	
		
 
        CheckConstraint('group_id != group_parent_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {'order_by': 'group_name'}

			




	
	
	
		
 

			




	
	
	
		
 
    SEP = ' &raquo; '

			




	
	
	
		
 

			




	
	
	
		
 
    group_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    group_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    group_name = Column(Unicode(255), nullable=False, unique=True)

			




	
	
	
		
 
    group_parent_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True)

			




	
	
	
		
 
    group_description = Column(Unicode(10000), nullable=False)

			




	
	
	
		
 
    enable_locking = Column(Boolean(), nullable=False, default=False)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

			




	
	
	
		
 
    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

			




	
	
	
		
 
    parent_group = relationship('RepoGroup', remote_side=group_id)

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, group_name='', parent_group=None):

			




	
	
	
		
 
        self.group_name = group_name

			




	
	
	
		
 
        self.parent_group = parent_group

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,

			




	
	
	
		
 
                                      self.group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _generate_choice(cls, repo_group):

			




	
	
	
		
 
        """Return tuple with group_id and name as html literal"""

			




	
	
	
		
 
        from webhelpers.html import literal

			




	
	
		
 
@@ -1732,339 +1732,339 @@ class Permission(Base, BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
        'group.none': 0,

			




	
	
	
		
 
        'group.read': 1,

			




	
	
	
		
 
        'group.write': 3,

			




	
	
	
		
 
        'group.admin': 4,

			




	
	
	
		
 

			




	
	
	
		
 
        'usergroup.none': 0,

			




	
	
	
		
 
        'usergroup.read': 1,

			




	
	
	
		
 
        'usergroup.write': 3,

			




	
	
	
		
 
        'usergroup.admin': 4,

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.repogroup.create.false': 0,

			




	
	
	
		
 
        'hg.repogroup.create.true': 1,

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.usergroup.create.false': 0,

			




	
	
	
		
 
        'hg.usergroup.create.true': 1,

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.fork.none': 0,

			




	
	
	
		
 
        'hg.fork.repository': 1,

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.create.none': 0,

			




	
	
	
		
 
        'hg.create.repository': 1

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    permission_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    permission_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    permission_name = Column(String(255), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('%s:%s')>" % (

			




	
	
	
		
 
            self.__class__.__name__, self.permission_id, self.permission_name

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, key):

			




	
	
	
		
 
        return cls.query().filter(cls.permission_name == key).scalar()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_default_perms(cls, default_user_id):

			




	
	
	
		
 
        q = Session().query(UserRepoToPerm, Repository, cls) \

			




	
	
	
		
 
         .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id)) \

			




	
	
	
		
 
         .join((cls, UserRepoToPerm.permission_id == cls.permission_id)) \

			




	
	
	
		
 
         .filter(UserRepoToPerm.user_id == default_user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_default_group_perms(cls, default_user_id):

			




	
	
	
		
 
        q = Session().query(UserRepoGroupToPerm, RepoGroup, cls) \

			




	
	
	
		
 
         .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id)) \

			




	
	
	
		
 
         .join((cls, UserRepoGroupToPerm.permission_id == cls.permission_id)) \

			




	
	
	
		
 
         .filter(UserRepoGroupToPerm.user_id == default_user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_default_user_group_perms(cls, default_user_id):

			




	
	
	
		
 
        q = Session().query(UserUserGroupToPerm, UserGroup, cls) \

			




	
	
	
		
 
         .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id)) \

			




	
	
	
		
 
         .join((cls, UserUserGroupToPerm.permission_id == cls.permission_id)) \

			




	
	
	
		
 
         .filter(UserUserGroupToPerm.user_id == default_user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserRepoToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'repo_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'repository_id', 'permission_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    repo_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    repo_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 
    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    repository = relationship('Repository')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, user, repository, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.user = user

			




	
	
	
		
 
        n.repository = repository

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u'<%s => %s >' % (self.user, self.repository)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserUserGroupToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_user_group_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_user_group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_user_group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 
    user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    user_group = relationship('UserGroup')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, user, user_group, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.user = user

			




	
	
	
		
 
        n.user_group = user_group

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u'<%s => %s >' % (self.user, self.user_group)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'permission_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u'<%s => %s >' % (self.user, self.permission)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupRepoToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_group_repo_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 
    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    users_group = relationship('UserGroup')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 
    repository = relationship('Repository')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, users_group, repository, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.users_group = users_group

			




	
	
	
		
 
        n.repository = repository

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupUserGroupToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_group_user_group_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

			




	
	
	
		
 
        CheckConstraint('target_user_group_id != user_group_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_group_user_group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_group_user_group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    target_user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 
    user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

			




	
	
	
		
 
    user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, target_user_group, user_group, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.target_user_group = target_user_group

			




	
	
	
		
 
        n.user_group = user_group

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_group_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('users_group_id', 'permission_id',),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    users_group = relationship('UserGroup')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserRepoGroupToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_repo_group_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'group_id', 'permission_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    group = relationship('RepoGroup')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, user, repository_group, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.user = user

			




	
	
	
		
 
        n.group = repository_group

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupRepoGroupToPerm(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_group_repo_group_to_perm'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('users_group_id', 'group_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_repo_group_to_perm_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    users_group_repo_group_to_perm_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




	
	
	
		
 
    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False)

			




	
	
	
		
 
    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    users_group = relationship('UserGroup')

			




	
	
	
		
 
    permission = relationship('Permission')

			




	
	
	
		
 
    group = relationship('RepoGroup')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, user_group, repository_group, permission):

			




	
	
	
		
 
        n = cls()

			




	
	
	
		
 
        n.users_group = user_group

			




	
	
	
		
 
        n.group = repository_group

			




	
	
	
		
 
        n.permission = permission

			




	
	
	
		
 
        Session().add(n)

			




	
	
	
		
 
        return n

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Statistics(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'statistics'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
         _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    stat_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    stat_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True)

			




	
	
	
		
 
    stat_on_revision = Column(Integer(), nullable=False)

			




	
	
	
		
 
    commit_activity = Column(LargeBinary(1000000), nullable=False)#JSON data

			




	
	
	
		
 
    commit_activity_combined = Column(LargeBinary(), nullable=False)#JSON data

			




	
	
	
		
 
    languages = Column(LargeBinary(1000000), nullable=False)#JSON data

			




	
	
	
		
 

			




	
	
	
		
 
    repository = relationship('Repository', single_parent=True)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserFollowing(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_followings'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'follows_repository_id'),

			




	
	
	
		
 
        UniqueConstraint('user_id', 'follows_user_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_following_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    user_following_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

			




	
	
	
		
 
    follows_user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True)

			




	
	
	
		
 
    follows_from = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

			




	
	
	
		
 

			




	
	
	
		
 
    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

			




	
	
	
		
 
    follows_repository = relationship('Repository', order_by='Repository.repo_name')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_repo_followers(cls, repo_id):

			




	
	
	
		
 
        return cls.query().filter(cls.follows_repo_id == repo_id)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class CacheInvalidation(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'cache_invalidation'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('key_idx', 'cache_key'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # cache_id, not used

			




	
	
	
		
 
    cache_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    cache_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    # cache_key as created by _get_cache_key

			




	
	
	
		
 
    cache_key = Column(Unicode(255), nullable=False, unique=True)

			




	
	
	
		
 
    # cache_args is a repo_name

			




	
	
	
		
 
    cache_args = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    # instance sets cache_active True when it is caching, other instances set

			




	
	
	
		
 
    # cache_active to False to indicate that this cache is invalid

			




	
	
	
		
 
    cache_active = Column(Boolean(), nullable=False, default=False)

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, cache_key, repo_name=''):

			




	
	
	
		
 
        self.cache_key = cache_key

			




	
	
	
		
 
        self.cache_args = repo_name

			




	
	
	
		
 
        self.cache_active = False

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('%s:%s[%s]')>" % (

			




	
	
	
		
 
            self.__class__.__name__,

			




	
	
	
		
 
            self.cache_id, self.cache_key, self.cache_active)

			




	
	
	
		
 

			




	
	
	
		
 
    def _cache_key_partition(self):

			




	
	
	
		
 
        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

			




	
	
	
		
 
        return prefix, repo_name, suffix

			




	
	
	
		
 

			




	
	
	
		
 
    def get_prefix(self):

			




	
	
	
		
 
        """

			




	
	
		
 
@@ -2147,49 +2147,49 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
            inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

			




	
	
	
		
 
            if inv_obj is None:

			




	
	
	
		
 
                log.error('failed to create CacheInvalidation entry')

			




	
	
	
		
 
                # TODO: fail badly?

			




	
	
	
		
 
            # else: TOCTOU - another thread added the key at the same time; no further action required

			




	
	
	
		
 
        return False

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_valid_cache_keys(cls):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Return opaque object with information of which caches still are valid

			




	
	
	
		
 
        and can be used without checking for invalidation.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return set(inv_obj.cache_key for inv_obj in cls.query().filter(cls.cache_active).all())

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class ChangesetComment(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'changeset_comments'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('cc_revision_idx', 'revision'),

			




	
	
	
		
 
        Index('cc_pull_request_id_idx', 'pull_request_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    comment_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    comment_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    revision = Column(String(40), nullable=True)

			




	
	
	
		
 
    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

			




	
	
	
		
 
    line_no = Column(Unicode(10), nullable=True)

			




	
	
	
		
 
    f_path = Column(Unicode(1000), nullable=True)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    text = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    modified_at = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    author = relationship('User')

			




	
	
	
		
 
    repo = relationship('Repository')

			




	
	
	
		
 
    # status_change is frequently used directly in templates - make it a lazy

			




	
	
	
		
 
    # join to avoid fetching each related ChangesetStatus on demand.

			




	
	
	
		
 
    # There will only be one ChangesetStatus referencing each comment so the join will not explode.

			




	
	
	
		
 
    status_change = relationship('ChangesetStatus',

			




	
	
	
		
 
                                 cascade="all, delete-orphan", lazy='joined')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_users(cls, revision=None, pull_request_id=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns user associated with this ChangesetComment. ie those

			




	
	
	
		
 
        who actually commented

			




	
	
		
 
@@ -2222,91 +2222,91 @@ class ChangesetStatus(Base, BaseModel):

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('cs_revision_idx', 'revision'),

			




	
	
	
		
 
        Index('cs_version_idx', 'version'),

			




	
	
	
		
 
        Index('cs_pull_request_id_idx', 'pull_request_id'),

			




	
	
	
		
 
        Index('cs_changeset_comment_id_idx', 'changeset_comment_id'),

			




	
	
	
		
 
        Index('cs_pull_request_id_user_id_version_idx', 'pull_request_id', 'user_id', 'version'),

			




	
	
	
		
 
        Index('cs_repo_id_pull_request_id_idx', 'repo_id', 'pull_request_id'),

			




	
	
	
		
 
        UniqueConstraint('repo_id', 'revision', 'version'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

			




	
	
	
		
 
    STATUS_APPROVED = 'approved'

			




	
	
	
		
 
    STATUS_REJECTED = 'rejected' # is shown as "Not approved" - TODO: change database content / scheme

			




	
	
	
		
 
    STATUS_UNDER_REVIEW = 'under_review'

			




	
	
	
		
 

			




	
	
	
		
 
    STATUSES = [

			




	
	
	
		
 
        (STATUS_NOT_REVIEWED, _("Not reviewed")),  # (no icon) and default

			




	
	
	
		
 
        (STATUS_UNDER_REVIEW, _("Under review")),

			




	
	
	
		
 
        (STATUS_REJECTED, _("Not approved")),

			




	
	
	
		
 
        (STATUS_APPROVED, _("Approved")),

			




	
	
	
		
 
    ]

			




	
	
	
		
 
    STATUSES_DICT = dict(STATUSES)

			




	
	
	
		
 

			




	
	
	
		
 
    changeset_status_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    changeset_status_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    revision = Column(String(40), nullable=True)

			




	
	
	
		
 
    status = Column(String(128), nullable=False, default=DEFAULT)

			




	
	
	
		
 
    changeset_comment_id = Column(Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)

			




	
	
	
		
 
    modified_at = Column(DateTime(), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    version = Column(Integer(), nullable=False, default=0)

			




	
	
	
		
 
    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

			




	
	
	
		
 

			




	
	
	
		
 
    author = relationship('User')

			




	
	
	
		
 
    repo = relationship('Repository')

			




	
	
	
		
 
    comment = relationship('ChangesetComment')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('%s:%s')>" % (

			




	
	
	
		
 
            self.__class__.__name__,

			




	
	
	
		
 
            self.status, self.author

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_status_lbl(cls, value):

			




	
	
	
		
 
        return cls.STATUSES_DICT.get(value)

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def status_lbl(self):

			




	
	
	
		
 
        return ChangesetStatus.get_status_lbl(self.status)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class PullRequest(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'pull_requests'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('pr_org_repo_id_idx', 'org_repo_id'),

			




	
	
	
		
 
        Index('pr_other_repo_id_idx', 'other_repo_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # values for .status

			




	
	
	
		
 
    STATUS_NEW = u'new'

			




	
	
	
		
 
    STATUS_CLOSED = u'closed'

			




	
	
	
		
 

			




	
	
	
		
 
    pull_request_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    pull_request_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    title = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    description = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    _revisions = Column('revisions', UnicodeText(), nullable=False)

			




	
	
	
		
 
    org_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    org_ref = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    other_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    other_ref = Column(Unicode(255), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def revisions(self):

			




	
	
	
		
 
        return self._revisions.split(':')

			




	
	
	
		
 

			




	
	
	
		
 
    @revisions.setter

			




	
	
	
		
 
    def revisions(self, val):

			




	
	
	
		
 
        self._revisions = safe_unicode(':'.join(val))

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def org_ref_parts(self):

			




	
	
	
		
 
        return self.org_ref.split(':')

			




	
	
	
		
 

			




	
	
		
 
@@ -2363,71 +2363,71 @@ class PullRequest(Base, BaseModel):

			




	
	
	
		
 
        import kallithea.lib.helpers as h

			




	
	
	
		
 
        b = self.org_ref_parts[1]

			




	
	
	
		
 
        if b != self.other_ref_parts[1]:

			




	
	
	
		
 
            s = '/_/' + b

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            s = '/_/' + self.title

			




	
	
	
		
 
        kwargs['extra'] = urlreadable(s)

			




	
	
	
		
 
        if canonical:

			




	
	
	
		
 
            return h.canonical_url('pullrequest_show', repo_name=self.other_repo.repo_name,

			




	
	
	
		
 
                                   pull_request_id=self.pull_request_id, **kwargs)

			




	
	
	
		
 
        return h.url('pullrequest_show', repo_name=self.other_repo.repo_name,

			




	
	
	
		
 
                     pull_request_id=self.pull_request_id, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
class PullRequestReviewers(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'pull_request_reviewers'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('pull_request_reviewers_user_id_idx', 'user_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, user=None, pull_request=None):

			




	
	
	
		
 
        self.user = user

			




	
	
	
		
 
        self.pull_request = pull_request

			




	
	
	
		
 

			




	
	
	
		
 
    pull_requests_reviewers_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    pull_requests_reviewers_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Notification(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'notifications'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('notification_type_idx', 'type'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    TYPE_CHANGESET_COMMENT = u'cs_comment'

			




	
	
	
		
 
    TYPE_MESSAGE = u'message'

			




	
	
	
		
 
    TYPE_MENTION = u'mention' # not used

			




	
	
	
		
 
    TYPE_REGISTRATION = u'registration'

			




	
	
	
		
 
    TYPE_PULL_REQUEST = u'pull_request'

			




	
	
	
		
 
    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

			




	
	
	
		
 

			




	
	
	
		
 
    notification_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    notification_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    subject = Column(Unicode(512), nullable=False)

			




	
	
	
		
 
    body = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    created_by = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    type_ = Column('type', Unicode(255), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    created_by_user = relationship('User')

			




	
	
	
		
 
    notifications_to_users = relationship('UserNotification', cascade="all, delete-orphan")

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def recipients(self):

			




	
	
	
		
 
        return [x.user for x in UserNotification.query()

			




	
	
	
		
 
                .filter(UserNotification.notification == self)

			




	
	
	
		
 
                .order_by(UserNotification.user_id.asc()).all()]

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create(cls, created_by, subject, body, recipients, type_=None):

			




	
	
	
		
 
        if type_ is None:

			




	
	
	
		
 
            type_ = Notification.TYPE_MESSAGE

			




	
	
	
		
 

			




	
	
	
		
 
        notification = cls()

			




	
	
	
		
 
        notification.created_by_user = created_by

			




	
	
	
		
 
        notification.subject = subject

			




	
	
	
		
 
        notification.body = body

			




	
	
		
 
@@ -2464,49 +2464,49 @@ class UserNotification(Base, BaseModel):

			




	
	
	
		
 
    notification_id = Column(Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

			




	
	
	
		
 
    read = Column(Boolean, nullable=False, default=False)

			




	
	
	
		
 
    sent_on = Column(DateTime(timezone=False), nullable=True) # FIXME: not nullable?

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    notification = relationship('Notification')

			




	
	
	
		
 

			




	
	
	
		
 
    def mark_as_read(self):

			




	
	
	
		
 
        self.read = True

			




	
	
	
		
 
        Session().add(self)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Gist(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'gists'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('g_gist_access_id_idx', 'gist_access_id'),

			




	
	
	
		
 
        Index('g_created_on_idx', 'created_on'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    GIST_PUBLIC = u'public'

			




	
	
	
		
 
    GIST_PRIVATE = u'private'

			




	
	
	
		
 
    DEFAULT_FILENAME = u'gistfile1.txt'

			




	
	
	
		
 

			




	
	
	
		
 
    gist_id = Column(Integer(), unique=True, primary_key=True)

			




	
	
	
		
 
    gist_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    gist_access_id = Column(Unicode(250), nullable=False)

			




	
	
	
		
 
    gist_description = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    gist_expires = Column(Float(53), nullable=False)

			




	
	
	
		
 
    gist_type = Column(Unicode(128), nullable=False)

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    modified_at = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    owner = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    def __repr__(self):

			




	
	
	
		
 
        return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_or_404(cls, id_):

			




	
	
	
		
 
        res = cls.query().filter(cls.gist_access_id == id_).scalar()

			




	
	
	
		
 
        if res is None:

			




	
	
	
		
 
            raise HTTPNotFound

			




	
	
	
		
 
        return res

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_access_id(cls, gist_access_id):

			




	
	
	
		
 
        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

			




	
	
	
		
 

			




	
	
		
 
@@ -2548,27 +2548,27 @@ class Gist(Base, BaseModel):

			




	
	
	
		
 
        )

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
        )

			




	
	
	
		
 
        data.update(self.get_api_data())

			




	
	
	
		
 
        return data

			




	
	
	
		
 
    ## SCM functions

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def scm_instance(self):

			




	
	
	
		
 
        from kallithea.lib.vcs import get_repo

			




	
	
	
		
 
        base_path = self.base_path()

			




	
	
	
		
 
        return get_repo(os.path.join(*map(safe_str,

			




	
	
	
		
 
                                          [base_path, self.gist_access_id])))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class DbMigrateVersion(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'db_migrate_version'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    repository_id = Column(String(250), unique=True, primary_key=True)

			




	
	
	
		
 
    repository_id = Column(String(250), primary_key=True)

			




	
	
	
		
 
    repository_path = Column(Text, nullable=False)

			




	
	
	
		
 
    version = Column(Integer, nullable=False)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.