Changeset - ddefc55eaf08
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Mads Kiilerich - 10 years ago 2016-01-05 16:30:11
madski@unity3d.com
db: introduce _table_args_default_dict with dict values for __table_args__

DRY.
1 file changed with 56 insertions and 65 deletions:
kallithea/model/db.py
56
65
0 comments (0 inline, 0 general)
kallithea/model/db.py
➞
Show inline comments
 
@@ -137,55 +137,59 @@ class BaseModel(object):
 
    @classmethod
 
    def getAll(cls):
 
        # deprecated and left for backward compatibility
 
        return cls.get_all()
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_all(cls):

			




	
	
	
		
 
        return cls.query().all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def delete(cls, id_):

			




	
	
	
		
 
        obj = cls.query().get(id_)

			




	
	
	
		
 
        Session().delete(obj)

			




	
	
	
		
 

			




	
	
	
		
 
    def __repr__(self):

			




	
	
	
		
 
        if hasattr(self, '__unicode__'):

			




	
	
	
		
 
            # python repr needs to return str

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                return safe_str(self.__unicode__())

			




	
	
	
		
 
            except UnicodeDecodeError:

			




	
	
	
		
 
                pass

			




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

			




	
	
	
		
 
        UniqueConstraint('app_settings_name'),

			




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

			




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

			




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

			




	
	
		
 
@@ -307,50 +311,49 @@ class Setting(Base, BaseModel):

			




	
	
	
		
 
        return fd

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_server_info(cls):

			




	
	
	
		
 
        import pkg_resources

			




	
	
	
		
 
        import platform

			




	
	
	
		
 
        import kallithea

			




	
	
	
		
 
        from kallithea.lib.utils import check_git_version

			




	
	
	
		
 
        mods = [(p.project_name, p.version) for p in pkg_resources.working_set]

			




	
	
	
		
 
        info = {

			




	
	
	
		
 
            'modules': sorted(mods, key=lambda k: k[0].lower()),

			




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

			




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

			




	
	
	
		
 

			




	
	
		
 
@@ -375,51 +378,51 @@ class Ui(Base, BaseModel):

			




	
	
	
		
 
    def get_repos_location(cls):

			




	
	
	
		
 
        return cls.get_by_key('/').ui_value

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def create_or_update_hook(cls, key, val):

			




	
	
	
		
 
        new_ui = cls.get_by_key(key) or cls()

			




	
	
	
		
 
        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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    DEFAULT_USER = 'default'

			




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

			




	
	
	
		
 

			




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

			




	
	
		
 
@@ -673,165 +676,161 @@ class User(Base, BaseModel):

			




	
	
	
		
 
                api_key=user.api_key,

			




	
	
	
		
 
                api_keys=user.api_keys,

			




	
	
	
		
 
                last_login=user.last_login,

			




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

			




	
	
	
		
 
        UniqueConstraint('api_key'),

			




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

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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 {}

			




	
	
		
 
@@ -878,110 +877,109 @@ class UserGroup(Base, BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
    def get_api_data(self, with_members=True):

			




	
	
	
		
 
        user_group = self

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _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(), 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=False, unique=None, default=datetime.datetime.now)

			




	
	
	
		
 
    updated_on = Column(DateTime(timezone=False), nullable=False, 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

			




	
	
		
 
@@ -1458,50 +1456,49 @@ class Repository(Base, BaseModel):

			




	
	
	
		
 
    def __get_instance(self):

			




	
	
	
		
 
        repo_full_path = self.repo_full_path

			




	
	
	
		
 

			




	
	
	
		
 
        alias = get_scm(safe_str(repo_full_path))[0]

			




	
	
	
		
 
        log.debug('Creating instance of %s repository from %s',

			




	
	
	
		
 
                  alias, repo_full_path)

			




	
	
	
		
 
        backend = get_backend(alias)

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {'order_by': 'group_name'}

			




	
	
	
		
 

			




	
	
	
		
 
    SEP = ' &raquo; '

			




	
	
	
		
 

			




	
	
	
		
 
    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,

			




	
	
		
 
@@ -1638,51 +1635,51 @@ class RepoGroup(Base, BaseModel):

			




	
	
	
		
 
                       self.parent_group else [])

			




	
	
	
		
 
        return RepoGroup.url_sep().join(path_prefix + [group_name])

			




	
	
	
		
 

			




	
	
	
		
 
    def get_api_data(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Common function for generating api data

			




	
	
	
		
 

			




	
	
	
		
 
        """

			




	
	
	
		
 
        group = self

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
            group_id=group.group_id,

			




	
	
	
		
 
            group_name=group.group_name,

			




	
	
	
		
 
            group_description=group.group_description,

			




	
	
	
		
 
            parent_group=group.parent_group.group_name if group.parent_group else None,

			




	
	
	
		
 
            repositories=[x.repo_name for x in group.repositories],

			




	
	
	
		
 
            owner=group.user.username

			




	
	
	
		
 
        )

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Permission(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'permissions'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('p_perm_name_idx', 'permission_name'),

			




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

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    PERMS = [

			




	
	
	
		
 
        ('hg.admin', _('Kallithea Administrator')),

			




	
	
	
		
 

			




	
	
	
		
 
        ('repository.none', _('Default user has no access to new repositories')),

			




	
	
	
		
 
        ('repository.read', _('Default user has read access to new repositories')),

			




	
	
	
		
 
        ('repository.write', _('Default user has write access to new repositories')),

			




	
	
	
		
 
        ('repository.admin', _('Default user has admin access to new repositories')),

			




	
	
	
		
 

			




	
	
	
		
 
        ('group.none', _('Default user has no access to new repository groups')),

			




	
	
	
		
 
        ('group.read', _('Default user has read access to new repository groups')),

			




	
	
	
		
 
        ('group.write', _('Default user has write access to new repository groups')),

			




	
	
	
		
 
        ('group.admin', _('Default user has admin access to new repository groups')),

			




	
	
	
		
 

			




	
	
	
		
 
        ('usergroup.none', _('Default user has no access to new user groups')),

			




	
	
	
		
 
        ('usergroup.read', _('Default user has read access to new user groups')),

			




	
	
	
		
 
        ('usergroup.write', _('Default user has write access to new user groups')),

			




	
	
	
		
 
        ('usergroup.admin', _('Default user has admin access to new user groups')),

			




	
	
	
		
 

			




	
	
	
		
 
        ('hg.repogroup.create.false', _('Only admins can create repository groups')),

			




	
	
	
		
 
        ('hg.repogroup.create.true', _('Non-admins can create repository groups')),

			




	
	
	
		
 

			




	
	
	
		
 
        ('hg.usergroup.create.false', _('Only admins can create user groups')),

			




	
	
	
		
 
        ('hg.usergroup.create.true', _('Non-admins can create user groups')),

			




	
	
	
		
 

			




	
	
		
 
@@ -1771,298 +1768,295 @@ class Permission(Base, BaseModel):

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
         _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # cache_id, not used

			




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

			




	
	
	
		
 
    # cache_key as created by _get_cache_key

			




	
	
	
		
 
    cache_key = Column(String(255, convert_unicode=False))

			




	
	
	
		
 
    # cache_args is a repo_name

			




	
	
	
		
 
    cache_args = Column(String(255, convert_unicode=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=True, unique=None, 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

			




	
	
	
		
 

			




	
	
		
 
@@ -2144,51 +2138,51 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
        except sqlalchemy.exc.IntegrityError:

			




	
	
	
		
 
            log.error('commit of CacheInvalidation failed - retrying')

			




	
	
	
		
 
            Session().rollback()

			




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

			




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

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    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

			




	
	
		
 
@@ -2201,100 +2195,99 @@ class ChangesetComment(Base, BaseModel):

			




	
	
	
		
 
                .join(ChangesetComment.author)

			




	
	
	
		
 
        if revision is not None:

			




	
	
	
		
 
            q = q.filter(cls.revision == revision)

			




	
	
	
		
 
        elif pull_request_id is not None:

			




	
	
	
		
 
            q = q.filter(cls.pull_request_id == pull_request_id)

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    def url(self):

			




	
	
	
		
 
        anchor = "comment-%s" % self.comment_id

			




	
	
	
		
 
        import kallithea.lib.helpers as h

			




	
	
	
		
 
        if self.revision:

			




	
	
	
		
 
            return h.url('changeset_home', repo_name=self.repo.repo_name, revision=self.revision, anchor=anchor)

			




	
	
	
		
 
        elif self.pull_request_id is not None:

			




	
	
	
		
 
            return self.pull_request.url(anchor=anchor)

			




	
	
	
		
 

			




	
	
	
		
 
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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # values for .status

			




	
	
	
		
 
    STATUS_NEW = u'new'

			




	
	
	
		
 
    STATUS_CLOSED = u'closed'

			




	
	
	
		
 

			




	
	
	
		
 
    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

			




	
	
		
 
@@ -2342,70 +2335,68 @@ class PullRequest(Base, BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        return dict(

			




	
	
	
		
 
            revisions=self.revisions

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    def url(self, **kwargs):

			




	
	
	
		
 
        canonical = kwargs.pop('canonical', None)

			




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

			




	
	
	
		
 
        _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(), 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},

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
		
 
@@ -2424,72 +2415,72 @@ class Notification(Base, BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
        for recipient in recipients:

			




	
	
	
		
 
            un = UserNotification()

			




	
	
	
		
 
            un.notification = notification

			




	
	
	
		
 
            un.user_id = recipient.user_id

			




	
	
	
		
 
            # Mark notifications to self "pre-read" - should perhaps just be skipped

			




	
	
	
		
 
            if recipient == created_by:

			




	
	
	
		
 
                un.read = True

			




	
	
	
		
 
            Session().add(un)

			




	
	
	
		
 

			




	
	
	
		
 
        Session().add(notification)

			




	
	
	
		
 
        Session().flush() # assign notificaiton.notification_id

			




	
	
	
		
 
        return notification

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def description(self):

			




	
	
	
		
 
        from kallithea.model.notification import NotificationModel

			




	
	
	
		
 
        return NotificationModel().make_description(self)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserNotification(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_to_notification'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'notification_id'),

			




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

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    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}

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    GIST_PUBLIC = u'public'

			




	
	
	
		
 
    GIST_PRIVATE = u'private'

			




	
	
	
		
 
    DEFAULT_FILENAME = u'gistfile1.txt'

			




	
	
	
		
 

			




	
	
	
		
 
    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 res is None:

			




	
	
	
		
 
            raise HTTPNotFound

			




	
	
	
		
 
        return res

			




	
	
		
 
@@ -2533,30 +2524,30 @@ class Gist(Base, BaseModel):

			




	
	
	
		
 
            url=gist.gist_url(),

			




	
	
	
		
 
            expires=gist.gist_expires,

			




	
	
	
		
 
            created_on=gist.created_on,

			




	
	
	
		
 
        )

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    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.