Changeset - f8a714c2c5a1
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Mads Kiilerich - 10 years ago 2016-01-05 16:30:12
madski@unity3d.com
db: make sure all (non-primary) columns have nullable set explicitly

The default of nullable=True is rarely good for us so nullable should always be
specified unless there is a reason to allow nullable ... and if the default is
fine, xplicit is better than implicit.

The declared nulliness of some fields are changed where it seems like code
already enforced it.

Some fields are marked as FIXME when they need (trivial?) data conversion to
convert NULLs to default values.
1 file changed with 68 insertions and 68 deletions:
kallithea/model/db.py
68
68
0 comments (0 inline, 0 general)
kallithea/model/db.py
➞
Show inline comments
 
@@ -159,51 +159,51 @@ class BaseModel(object):
 

			




	
	
	
		
 

			




	
	
	
		
 
_table_args_default_dict = {'extend_existing': True,

			




	
	
	
		
 
                            'mysql_engine': 'InnoDB',

			




	
	
	
		
 
                            'mysql_charset': 'utf8',

			




	
	
	
		
 
                            'sqlite_autoincrement': True,

			




	
	
	
		
 
                           }

			




	
	
	
		
 

			




	
	
	
		
 
class Setting(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = DB_PREFIX + 'settings'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    SETTINGS_TYPES = {

			




	
	
	
		
 
        'str': safe_str,

			




	
	
	
		
 
        'int': safe_int,

			




	
	
	
		
 
        'unicode': safe_unicode,

			




	
	
	
		
 
        'bool': str2bool,

			




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

			




	
	
	
		
 
    }

			




	
	
	
		
 
    DEFAULT_UPDATE_URL = ''

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
    _app_settings_type = Column("app_settings_type", String(255), nullable=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.app_settings_name = key

			




	
	
	
		
 
        self.app_settings_value = val

			




	
	
	
		
 
        self.app_settings_type = type

			




	
	
	
		
 

			




	
	
	
		
 
    @validates('_app_settings_value')

			




	
	
	
		
 
    def validate_settings_value(self, key, val):

			




	
	
	
		
 
        assert type(val) == unicode

			




	
	
	
		
 
        return val

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def app_settings_value(self):

			




	
	
	
		
 
        v = self._app_settings_value

			




	
	
	
		
 
        _type = self.app_settings_type

			




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

			




	
	
	
		
 
        return converter(v)

			




	
	
	
		
 

			




	
	
	
		
 
    @app_settings_value.setter

			




	
	
	
		
 
    def app_settings_value(self, val):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Setter that will always make sure we use unicode in app_settings_value

			




	
	
	
		
 

			




	
	
	
		
 
        :param val:

			




	
	
		
 
@@ -324,52 +324,52 @@ class Setting(Base, BaseModel):

			




	
	
	
		
 
            'git_version': safe_unicode(check_git_version()),

			




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

			




	
	
	
		
 
        }

			




	
	
	
		
 
        return info

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Ui(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = DB_PREFIX + 'ui'

			




	
	
	
		
 
    __table_args__ = (

			




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

			




	
	
	
		
 
        # Ui.get_by_key has been replaced by the composite key

			




	
	
	
		
 
        UniqueConstraint('ui_key'),

			




	
	
	
		
 
        UniqueConstraint('ui_section', 'ui_key'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    HOOK_UPDATE = 'changegroup.update'

			




	
	
	
		
 
    HOOK_REPO_SIZE = 'changegroup.repo_size'

			




	
	
	
		
 
    HOOK_PUSH = 'changegroup.push_logger'

			




	
	
	
		
 
    HOOK_PRE_PUSH = 'prechangegroup.pre_push'

			




	
	
	
		
 
    HOOK_PULL = 'outgoing.pull_logger'

			




	
	
	
		
 
    HOOK_PRE_PULL = 'preoutgoing.pre_pull'

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, 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):

			




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

			




	
	
	
		
 
        q = q.filter(cls.ui_section == 'hooks')

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_repos_location(cls):

			




	
	
		
 
@@ -381,62 +381,62 @@ 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__ = (

			




	
	
	
		
 
        Index('u_username_idx', 'username'),

			




	
	
	
		
 
        Index('u_email_idx', 'email'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    DEFAULT_USER = 'default'

			




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

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user_log = relationship('UserLog')

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    repositories = relationship('Repository')

			




	
	
	
		
 
    repo_groups = relationship('RepoGroup')

			




	
	
	
		
 
    user_groups = relationship('UserGroup')

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

			




	
	
	
		
 
    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')

			




	
	
	
		
 

			




	
	
	
		
 
    group_member = relationship('UserGroupMember', cascade='all')

			




	
	
	
		
 

			




	
	
	
		
 
    notifications = relationship('UserNotification', cascade='all')

			




	
	
	
		
 
    # notifications assigned to this user

			




	
	
	
		
 
    user_created_notifications = relationship('Notification', cascade='all')

			




	
	
	
		
 
    # comments created by this user

			




	
	
	
		
 
    user_comments = relationship('ChangesetComment', cascade='all')

			




	
	
	
		
 
    #extra emails for this user

			




	
	
	
		
 
    user_emails = relationship('UserEmailMap', cascade='all')

			




	
	
	
		
 
    #extra API keys

			




	
	
	
		
 
    user_api_keys = relationship('UserApiKeys', cascade='all')

			




	
	
		
 
@@ -676,165 +676,165 @@ 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'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    description = Column(UnicodeText(1024))

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def expired(self):

			




	
	
	
		
 
        if self.expires == -1:

			




	
	
	
		
 
            return False

			




	
	
	
		
 
        return time.time() > self.expires

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserEmailMap(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_email_map'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('uem_email_idx', 'email'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @validates('_email')

			




	
	
	
		
 
    def validate_email(self, key, email):

			




	
	
	
		
 
        # check if this email is not main one

			




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

			




	
	
	
		
 
        if main_email is not None:

			




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

			




	
	
	
		
 
        return email

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def email(self):

			




	
	
	
		
 
        return self._email

			




	
	
	
		
 

			




	
	
	
		
 
    @email.setter

			




	
	
	
		
 
    def email(self, val):

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserIpMap(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_ip_map'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'ip_addr'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {}

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _get_ip_range(cls, ip_addr):

			




	
	
	
		
 
        from kallithea.lib import ipaddr

			




	
	
	
		
 
        net = ipaddr.IPNetwork(address=ip_addr)

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        return dict(

			




	
	
	
		
 
          ip_addr=self.ip_addr,

			




	
	
	
		
 
          ip_range=self._get_ip_range(self.ip_addr)

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




	
	
	
		
 
                                            self.user_id, self.ip_addr)

			




	
	
	
		
 

			




	
	
	
		
 
class UserLog(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_logs'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    action = Column(UnicodeText(1200000), nullable=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




	
	
	
		
 
                                      self.repository_name,

			




	
	
	
		
 
                                      self.action)

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def action_as_day(self):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroup(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'users_groups'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
    user_group_description = Column(Unicode(10000), nullable=True)

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def group_data(self):

			




	
	
	
		
 
        if not self._group_data:

			




	
	
	
		
 
            return {}

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            return json.loads(self._group_data)

			




	
	
	
		
 
        except TypeError:

			




	
	
	
		
 
            return {}

			




	
	
	
		
 

			




	
	
	
		
 
    @group_data.setter

			




	
	
	
		
 
    def group_data(self, val):

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            self._group_data = json.dumps(val)

			




	
	
		
 
@@ -897,106 +897,106 @@ class UserGroupMember(Base, BaseModel):

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    users_group = relationship('UserGroup')

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.users_group_id = gr_id

			




	
	
	
		
 
        self.user_id = u_id

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class RepositoryField(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'repositories_fields'

			




	
	
	
		
 
    __table_args__ = (

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
    field_key = Column(String(250))

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    repository = relationship('Repository')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def field_key_prefixed(self):

			




	
	
	
		
 
        return 'ex_%s' % self.field_key

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def un_prefix_key(cls, key):

			




	
	
	
		
 
        if key.startswith(cls.PREFIX):

			




	
	
	
		
 
            return key[len(cls.PREFIX):]

			




	
	
	
		
 
        return key

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key_name(cls, key, repo):

			




	
	
	
		
 
        row = cls.query() \

			




	
	
	
		
 
                .filter(cls.repository == repo) \

			




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

			




	
	
	
		
 
        return row

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Repository(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'repositories'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('r_repo_name_idx', 'repo_name'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    STATE_CREATED = 'repo_state_created'

			




	
	
	
		
 
    STATE_PENDING = 'repo_state_pending'

			




	
	
	
		
 
    STATE_ERROR = 'repo_state_error'

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    _locked = Column("locked", String(255), nullable=True)

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




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

			




	
	
	
		
 
    group = relationship('RepoGroup')

			




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

			




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

			




	
	
	
		
 
    stats = relationship('Statistics', cascade='all', uselist=False)

			




	
	
	
		
 

			




	
	
	
		
 
    followers = relationship('UserFollowing',

			




	
	
	
		
 
                             primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',

			




	
	
	
		
 
                             cascade='all')

			




	
	
	
		
 
    extra_fields = relationship('RepositoryField',

			




	
	
	
		
 
                                cascade="all, delete-orphan")

			




	
	
	
		
 

			




	
	
	
		
 
    logs = relationship('UserLog')

			




	
	
	
		
 
    comments = relationship('ChangesetComment', cascade="all, delete-orphan")

			




	
	
	
		
 

			




	
	
	
		
 
    pull_requests_org = relationship('PullRequest',

			




	
	
	
		
 
                    primaryjoin='PullRequest.org_repo_id==Repository.repo_id',

			




	
	
	
		
 
                    cascade="all, delete-orphan")

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 
    __mapper_args__ = {'order_by': 'group_name'}

			




	
	
	
		
 

			




	
	
	
		
 
    SEP = ' &raquo; '

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.group_name = group_name

			




	
	
	
		
 
        self.parent_group = parent_group

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




	
	
	
		
 
                                      self.group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _generate_choice(cls, repo_group):

			




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

			




	
	
	
		
 
        from webhelpers.html import literal

			




	
	
	
		
 
        if repo_group is None:

			




	
	
	
		
 
            return (-1, u'-- %s --' % _('top level'))

			




	
	
	
		
 
        return repo_group.group_id, literal(cls.SEP.join(repo_group.full_path_splitted))

			




	
	
		
 
@@ -1717,49 +1717,49 @@ class Permission(Base, BaseModel):

			




	
	
	
		
 
        'group.none': 0,

			




	
	
	
		
 
        'group.read': 1,

			




	
	
	
		
 
        'group.write': 3,

			




	
	
	
		
 
        'group.admin': 4,

			




	
	
	
		
 

			




	
	
	
		
 
        'usergroup.none': 0,

			




	
	
	
		
 
        'usergroup.read': 1,

			




	
	
	
		
 
        'usergroup.write': 3,

			




	
	
	
		
 
        'usergroup.admin': 4,

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.fork.none': 0,

			




	
	
	
		
 
        'hg.fork.repository': 1,

			




	
	
	
		
 

			




	
	
	
		
 
        'hg.create.none': 0,

			




	
	
	
		
 
        'hg.create.repository': 1

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




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

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, key):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_default_perms(cls, default_user_id):

			




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

			




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

			




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

			




	
	
	
		
 
         .filter(UserRepoToPerm.user_id == default_user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        return q.all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_default_group_perms(cls, default_user_id):

			




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

			




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

			




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

			




	
	
		
 
@@ -1986,76 +1986,76 @@ class Statistics(Base, BaseModel):

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserFollowing(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'user_followings'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('user_id', 'follows_repository_id'),

			




	
	
	
		
 
        UniqueConstraint('user_id', 'follows_user_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_repo_followers(cls, repo_id):

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class CacheInvalidation(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'cache_invalidation'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('key_idx', 'cache_key'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # cache_id, not used

			




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

			




	
	
	
		
 
    # cache_key as created by _get_cache_key

			




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

			




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

			




	
	
	
		
 
    # cache_args is a repo_name

			




	
	
	
		
 
    cache_args = Column(Unicode(255))

			




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

			




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

			




	
	
	
		
 
    # cache_active to False to indicate that this cache is invalid

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.cache_key = cache_key

			




	
	
	
		
 
        self.cache_args = repo_name

			




	
	
	
		
 
        self.cache_active = False

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




	
	
	
		
 
            self.__class__.__name__,

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    def _cache_key_partition(self):

			




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

			




	
	
	
		
 
        return prefix, repo_name, suffix

			




	
	
	
		
 

			




	
	
	
		
 
    def get_prefix(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        get prefix that might have been used in _get_cache_key to

			




	
	
	
		
 
        generate self.cache_key. Only used for informational purposes

			




	
	
	
		
 
        in repo_edit.html.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        # prefix, repo_name, suffix

			




	
	
	
		
 
        return self._cache_key_partition()[0]

			




	
	
	
		
 

			




	
	
		
 
@@ -2133,52 +2133,52 @@ class CacheInvalidation(Base, BaseModel)

			




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

			




	
	
	
		
 
                # TODO: fail badly?

			




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

			




	
	
	
		
 
        return False

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_valid_cache_keys(cls):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Return opaque object with information of which caches still are valid

			




	
	
	
		
 
        and can be used without checking for invalidation.

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class ChangesetComment(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'changeset_comments'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('cc_revision_idx', 'revision'),

			




	
	
	
		
 
        Index('cc_pull_request_id_idx', 'pull_request_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
        who actually commented

			




	
	
	
		
 

			




	
	
	
		
 
        :param cls:

			




	
	
	
		
 
        :param revision:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        q = Session().query(User) \

			




	
	
		
 
@@ -2203,95 +2203,95 @@ class ChangesetStatus(Base, BaseModel):

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    author = relationship('User')

			




	
	
	
		
 
    repo = relationship('Repository')

			




	
	
	
		
 
    comment = relationship('ChangesetComment')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




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

			




	
	
	
		
 
            self.__class__.__name__,

			




	
	
	
		
 
            self.status, self.author

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_status_lbl(cls, value):

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # values for .status

			




	
	
	
		
 
    STATUS_NEW = u'new'

			




	
	
	
		
 
    STATUS_CLOSED = u'closed'

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
    description = Column(UnicodeText(10240))

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
    _revisions = Column('revisions', UnicodeText(20500), nullable=False)  # 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(':')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def other_ref_parts(self):

			




	
	
	
		
 
        return self.other_ref.split(':')

			




	
	
	
		
 

			




	
	
	
		
 
    owner = relationship('User')

			




	
	
	
		
 
    reviewers = relationship('PullRequestReviewers',

			




	
	
	
		
 
                             cascade="all, delete-orphan")

			




	
	
		
 
@@ -2334,74 +2334,74 @@ class PullRequest(Base, BaseModel):

			




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

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        self.user = user

			




	
	
	
		
 
        self.pull_request = pull_request

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    pull_request = relationship('PullRequest')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Notification(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'notifications'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('notification_type_idx', 'type'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    TYPE_CHANGESET_COMMENT = u'cs_comment'

			




	
	
	
		
 
    TYPE_MESSAGE = u'message'

			




	
	
	
		
 
    TYPE_MENTION = u'mention'

			




	
	
	
		
 
    TYPE_REGISTRATION = u'registration'

			




	
	
	
		
 
    TYPE_PULL_REQUEST = u'pull_request'

			




	
	
	
		
 
    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    created_by_user = relationship('User')

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def recipients(self):

			




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

			




	
	
	
		
 
                .filter(UserNotification.notification == self)

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




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

			




	
	
	
		
 
        if type_ is None:

			




	
	
	
		
 
            type_ = Notification.TYPE_MESSAGE

			




	
	
	
		
 

			




	
	
	
		
 
        notification = cls()

			




	
	
	
		
 
        notification.created_by_user = created_by

			




	
	
	
		
 
        notification.subject = subject

			




	
	
	
		
 
        notification.body = body

			




	
	
	
		
 
        notification.type_ = type_

			




	
	
	
		
 
        notification.created_on = datetime.datetime.now()

			




	
	
	
		
 

			




	
	
	
		
 
        for recipient in recipients:

			




	
	
	
		
 
            un = UserNotification()

			




	
	
		
 
@@ -2410,75 +2410,75 @@ class Notification(Base, BaseModel):

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User')

			




	
	
	
		
 
    notification = relationship('Notification')

			




	
	
	
		
 

			




	
	
	
		
 
    def mark_as_read(self):

			




	
	
	
		
 
        self.read = True

			




	
	
	
		
 
        Session().add(self)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Gist(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'gists'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('g_gist_access_id_idx', 'gist_access_id'),

			




	
	
	
		
 
        Index('g_created_on_idx', 'created_on'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    GIST_PUBLIC = u'public'

			




	
	
	
		
 
    GIST_PRIVATE = u'private'

			




	
	
	
		
 
    DEFAULT_FILENAME = u'gistfile1.txt'

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    gist_access_id = Column(Unicode(250))

			




	
	
	
		
 
    gist_description = Column(UnicodeText(1024))

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    owner = relationship('User')

			




	
	
	
		
 

			




	
	
	
		
 
    def __repr__(self):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_or_404(cls, id_):

			




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

			




	
	
	
		
 
        if res is None:

			




	
	
	
		
 
            raise HTTPNotFound

			




	
	
	
		
 
        return res

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_access_id(cls, gist_access_id):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    def gist_url(self):

			




	
	
	
		
 
        import kallithea

			




	
	
	
		
 
        alias_url = kallithea.CONFIG.get('gist_alias_url')

			




	
	
		
 
@@ -2518,26 +2518,26 @@ class Gist(Base, BaseModel):

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
        )

			




	
	
	
		
 
        data.update(self.get_api_data())

			




	
	
	
		
 
        return data

			




	
	
	
		
 
    ## SCM functions

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def scm_instance(self):

			




	
	
	
		
 
        from kallithea.lib.vcs import get_repo

			




	
	
	
		
 
        base_path = self.base_path()

			




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

			




	
	
	
		
 
                                          [base_path, self.gist_access_id])))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class DbMigrateVersion(Base, BaseModel):

			




	
	
	
		
 
    __tablename__ = 'db_migrate_version'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    repository_path = Column(Text)

			




	
	
	
		
 
    version = Column(Integer)

			




	
	
	
		
 
    repository_path = Column(Text, nullable=False)

			




	
	
	
		
 
    version = Column(Integer, nullable=False)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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