Changeset - a7b20e31bb36
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Mads Kiilerich - 11 years ago 2015-05-07 16:26:40
madski@unity3d.com
db: more consistently set primary keys to be unique, not nullable and without default

Setting primary_key will (in general) automatically set autoincrement and
setting a default is just odd.
1 file changed with 30 insertions and 30 deletions:
kallithea/model/db.py
30
30
0 comments (0 inline, 0 general)
kallithea/model/db.py
➞
Show inline comments
 
@@ -154,49 +154,49 @@ class BaseModel(object):
 
                return safe_str(self.__unicode__())
 
            except UnicodeDecodeError:
 
                pass
 
        return '<DB:%s>' % (self.__class__.__name__)
 

			




	
	
	
		
 

			




	
	
	
		
 
class Setting(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = DB_PREFIX + 'settings'

			




	
	
	
		
 

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('app_settings_name'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




	
	
	
		
 
    _app_settings_value = Column("app_settings_value", String(4096, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    _app_settings_type = Column("app_settings_type", String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 

			




	
	
	
		
 
    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):

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
            'py_version': platform.python_version(),

			




	
	
	
		
 
            'platform': safe_unicode(platform.platform()),

			




	
	
	
		
 
            '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__ = (

			




	
	
	
		
 
        UniqueConstraint('ui_key'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




	
	
	
		
 
    ui_section = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    ui_key = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    ui_value = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    ui_active = Column(Boolean(), nullable=True, unique=None, default=True)

			




	
	
	
		
 

			




	
	
	
		
 
    # def __init__(self, section='', key='', value=''):

			




	
	
	
		
 
    #     self.ui_section = section

			




	
	
	
		
 
    #     self.ui_key = key

			




	
	
	
		
 
    #     self.ui_value = value

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, key):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @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,

			




	
	
	
		
 
                                     cls.HOOK_PULL, cls.HOOK_PRE_PULL]))

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_custom_hooks(cls):

			




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

			




	
	
	
		
 
        new_ui.ui_section = 'hooks'

			




	
	
	
		
 
        new_ui.ui_active = True

			




	
	
	
		
 
        new_ui.ui_key = key

			




	
	
	
		
 
        new_ui.ui_value = val

			




	
	
	
		
 

			




	
	
	
		
 
        Session().add(new_ui)

			




	
	
	
		
 

			




	
	
	
		
 
    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__ = (

			




	
	
	
		
 
        UniqueConstraint('username'), UniqueConstraint('email'),

			




	
	
	
		
 
        Index('u_username_idx', 'username'),

			




	
	
	
		
 
        Index('u_email_idx', 'email'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    DEFAULT_USER = 'default'

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




	
	
	
		
 
    password = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    active = Column(Boolean(), nullable=True, unique=None, default=True)

			




	
	
	
		
 
    admin = Column(Boolean(), nullable=True, unique=None, default=False)

			




	
	
	
		
 
    name = Column("firstname", String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    lastname = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




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

			




	
	
	
		
 
    last_login = Column(DateTime(timezone=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    extern_type = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    extern_name = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




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

			




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

			




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

			




	
	
	
		
 
    _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data

			




	
	
	
		
 

			




	
	
	
		
 
    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')

			




	
	
	
		
 

			




	
	
		
 
@@ -654,163 +654,163 @@ class User(Base, BaseModel):

			




	
	
	
		
 
        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'),

			




	
	
	
		
 
        UniqueConstraint('api_key'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    user_api_key_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




	
	
	
		
 
    description = Column(UnicodeText(1024))

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        UniqueConstraint('email'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    email_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    ip_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




	
	
	
		
 
    ip_addr = Column(String(255, convert_unicode=False), nullable=True, unique=False, default=None)

			




	
	
	
		
 
    active = Column(Boolean(), nullable=True, unique=None, 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__ = (

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 
    user_log_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    repository_name = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    user_ip = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    action = Column(UnicodeText(1200000, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    action_date = Column(DateTime(timezone=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 

			




	
	
	
		
 
    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__ = (

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




	
	
	
		
 
    users_group_name = Column(String(255, convert_unicode=False), nullable=False, unique=True, default=None)

			




	
	
	
		
 
    user_group_description = Column(String(10000, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    users_group_active = Column(Boolean(), nullable=True, unique=None, default=None)

			




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

			




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

			




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

			




	
	
	
		
 
    _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data

			




	
	
	
		
 

			




	
	
	
		
 
    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)

			




	
	
		
 
@@ -858,114 +858,114 @@ 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__ = (

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_member_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    repo_field_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    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__ = (

			




	
	
	
		
 
        UniqueConstraint('repo_name'),

			




	
	
	
		
 
        Index('r_repo_name_idx', 'repo_name'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 
    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(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




	
	
	
		
 
    repo_name = Column(String(255, convert_unicode=False), nullable=False, unique=True, default=None)

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    clone_uri = Column(String(255, convert_unicode=False), nullable=True, unique=False, default=None)

			




	
	
	
		
 
    repo_type = Column(String(255, convert_unicode=False), nullable=False, unique=False, default=None)

			




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

			




	
	
	
		
 
    private = Column(Boolean(), nullable=True, unique=None, default=None)

			




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

			




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

			




	
	
	
		
 
    description = Column(String(10000, convert_unicode=False), nullable=True, unique=None, default=None)

			




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

			




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

			




	
	
	
		
 
    _landing_revision = Column("landing_revision", String(255, convert_unicode=False), nullable=False, unique=False, default=None)

			




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

			




	
	
	
		
 
    _locked = Column("locked", String(255, convert_unicode=False), nullable=True, unique=False, default=None)

			




	
	
	
		
 
    _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) #JSON data

			




	
	
	
		
 

			




	
	
	
		
 
    fork_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)

			




	
	
	
		
 
    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

			




	
	
	
		
 

			




	
	
	
		
 
    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')

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        if alias == 'hg':

			




	
	
	
		
 
            repo = backend(safe_str(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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {'order_by': 'group_name'}

			




	
	
	
		
 

			




	
	
	
		
 
    SEP = ' &raquo; '

			




	
	
	
		
 

			




	
	
	
		
 
    group_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




	
	
	
		
 
    group_name = Column(String(255, convert_unicode=False), nullable=False, unique=True, default=None)

			




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

			




	
	
	
		
 
    group_description = Column(String(10000, convert_unicode=False), nullable=True, unique=None, default=None)

			




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

			




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

			




	
	
	
		
 
    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):

			




	
	
	
		
 
        from webhelpers.html import literal as _literal

			




	
	
	
		
 
        _name = lambda k: _literal(cls.SEP.join(k))

			




	
	
		
 
@@ -1708,320 +1708,320 @@ class Permission(Base, BaseModel):

			




	
	
	
		
 
        'repository.write': 3,

			




	
	
	
		
 
        'repository.admin': 4,

			




	
	
	
		
 

			




	
	
	
		
 
        '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(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




	
	
	
		
 
    permission_name = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    permission_longname = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    repo_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    user_user_group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    user_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    user_group_user_group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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',),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    users_group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_repo_group_to_perm_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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__ = (

			




	
	
	
		
 
         UniqueConstraint('repository_id'),

			




	
	
	
		
 
         {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
          'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    stat_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    user_following_id = Column(Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    follows_from = Column(DateTime(timezone=False), nullable=True, unique=None, 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__ = (

			




	
	
	
		
 
        UniqueConstraint('cache_key'),

			




	
	
	
		
 
        Index('key_idx', 'cache_key'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 
    # cache_id, not used

			




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

			




	
	
	
		
 
        if inv_obj.cache_active:

			




	
	
	
		
 
            return True

			




	
	
	
		
 
        inv_obj.cache_active = True

			




	
	
	
		
 
        Session().add(inv_obj)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




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

			




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

			




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

			




	
	
	
		
 
    revision = Column(String(40))

			




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

			




	
	
	
		
 
    line_no = Column(Unicode(10))

			




	
	
	
		
 
    hl_lines = Column(Unicode(512))

			




	
	
	
		
 
    f_path = Column(Unicode(1000))

			




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

			




	
	
	
		
 
    text = Column(UnicodeText(25000), 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

			




	
	
		
 
@@ -2187,92 +2187,92 @@ class ChangesetComment(Base, BaseModel):

			




	
	
	
		
 
class ChangesetStatus(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'changeset_statuses'

			




	
	
	
		
 
    __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'),

			




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

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

			




	
	
	
		
 
    STATUS_APPROVED = 'approved'

			




	
	
	
		
 
    STATUS_REJECTED = 'rejected'

			




	
	
	
		
 
    STATUS_UNDER_REVIEW = 'under_review'

			




	
	
	
		
 

			




	
	
	
		
 
    STATUSES = [

			




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

			




	
	
	
		
 
        (STATUS_APPROVED, _("Approved")),

			




	
	
	
		
 
        (STATUS_REJECTED, _("Rejected")),

			




	
	
	
		
 
        (STATUS_UNDER_REVIEW, _("Under Review")),

			




	
	
	
		
 
    ]

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    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 dict(cls.STATUSES).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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # values for .status

			




	
	
	
		
 
    STATUS_NEW = u'new'

			




	
	
	
		
 
    STATUS_CLOSED = u'closed'

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
    description = Column(UnicodeText(10240))

			




	
	
	
		
 
    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, unique=None)

			




	
	
	
		
 
    _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max

			




	
	
	
		
 
    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(':')

			




	
	
	
		
 

			




	
	
		
 
@@ -2325,72 +2325,72 @@ 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__ = (

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.user = user

			




	
	
	
		
 
        self.pull_request = pull_request

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    pull_requests_reviewers_id = Column(Integer(), nullable=False, unique=True, 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=True)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Notification(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'notifications'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('notification_type_idx', 'type'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    TYPE_CHANGESET_COMMENT = u'cs_comment'

			




	
	
	
		
 
    TYPE_MESSAGE = u'message'

			




	
	
	
		
 
    TYPE_MENTION = u'mention'

			




	
	
	
		
 
    TYPE_REGISTRATION = u'registration'

			




	
	
	
		
 
    TYPE_PULL_REQUEST = u'pull_request'

			




	
	
	
		
 
    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
    body = Column(UnicodeText(50000), nullable=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    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

			




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

			




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

			




	
	
	
		
 
    read = Column(Boolean, default=False)

			




	
	
	
		
 
    sent_on = Column(DateTime(timezone=False), nullable=True, unique=None)

			




	
	
	
		
 

			




	
	
	
		
 
    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'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

			




	
	
	
		
 
    )

			




	
	
	
		
 
    GIST_PUBLIC = u'public'

			




	
	
	
		
 
    GIST_PRIVATE = u'private'

			




	
	
	
		
 
    DEFAULT_FILENAME = u'gistfile1.txt'

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
    gist_access_id = Column(Unicode(250))

			




	
	
	
		
 
    gist_description = Column(UnicodeText(1024))

			




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

			




	
	
	
		
 
    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 not res:

			




	
	
	
		
 
            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()

			




	
	
	
		
 

			




	
	
		
 
@@ -2507,27 +2507,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__ = (

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

			




	
	
	
		
 
    )

			




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

			




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

			




	
	
	
		
 
    repository_path = Column(Text)

			




	
	
	
		
 
    version = Column(Integer)

			




        

    



    


    



    



      

      





    
    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.