diff --git a/rhodecode/model/db.py b/rhodecode/model/db.py old mode 100644 new mode 100755 --- a/rhodecode/model/db.py +++ b/rhodecode/model/db.py @@ -4,7 +4,7 @@ ~~~~~~~~~~~~~~~~~~ Database Models for RhodeCode - + :created_on: Apr 08, 2010 :author: marcink :copyright: (C) 2009-2011 Marcin Kuzminski @@ -22,23 +22,121 @@ # # You should have received a copy of the GNU General Public License # along with this program. If not, see . + +import os import logging import datetime +import traceback from datetime import date from sqlalchemy import * from sqlalchemy.exc import DatabaseError -from sqlalchemy.orm import relationship, backref +from sqlalchemy.orm import relationship, backref, joinedload, class_mapper from sqlalchemy.orm.interfaces import MapperExtension +from beaker.cache import cache_region, region_invalidate + +from vcs import get_backend +from vcs.utils.helpers import get_scm +from vcs.exceptions import VCSError +from vcs.utils.lazy import LazyProperty + +from rhodecode.lib.exceptions import UsersGroupsAssignedException +from rhodecode.lib import str2bool, json, safe_str, get_changeset_safe,\ + generate_api_key + from rhodecode.model.meta import Base, Session +from rhodecode.model.caching_query import FromCache log = logging.getLogger(__name__) +#============================================================================== +# BASE CLASSES +#============================================================================== -class RhodeCodeSettings(Base): +class ModelSerializer(json.JSONEncoder): + """ + Simple Serializer for JSON, + + usage:: + + to make object customized for serialization implement a __json__ + method that will return a dict for serialization into json + + example:: + + class Task(object): + + def __init__(self, name, value): + self.name = name + self.value = value + + def __json__(self): + return dict(name=self.name, + value=self.value) + + """ + + def default(self, obj): + + if hasattr(obj, '__json__'): + return obj.__json__() + else: + return json.JSONEncoder.default(self, obj) + +class BaseModel(object): + """Base Model for all classess + + """ + + @classmethod + def _get_keys(cls): + """return column names for this model """ + return class_mapper(cls).c.keys() + + def get_dict(self): + """return dict with keys and values corresponding + to this model data """ + + d = {} + for k in self._get_keys(): + d[k] = getattr(self, k) + return d + + def get_appstruct(self): + """return list with keys and values tupples corresponding + to this model data """ + + l = [] + for k in self._get_keys(): + l.append((k, getattr(self, k),)) + return l + + def populate_obj(self, populate_dict): + """populate model with data from given populate_dict""" + + for k in self._get_keys(): + if k in populate_dict: + setattr(self, k, populate_dict[k]) + + @classmethod + def query(cls): + return Session.query(cls) + + @classmethod + def get(cls, id_): + return Session.query(cls).get(id_) + + @classmethod + def delete(cls, id_): + obj = Session.query(cls).get(id_) + Session.delete(obj) + Session.commit() + + +class RhodeCodeSettings(Base, BaseModel): __tablename__ = 'rhodecode_settings' - __table_args__ = (UniqueConstraint('app_settings_name'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('app_settings_name'), {'extend_existing':True}) app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) app_settings_name = Column("app_settings_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) app_settings_value = Column("app_settings_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -51,9 +149,52 @@ class RhodeCodeSettings(Base): return "<%s('%s:%s')>" % (self.__class__.__name__, self.app_settings_name, self.app_settings_value) -class RhodeCodeUi(Base): + + @classmethod + def get_by_name(cls, ldap_key): + return Session.query(cls)\ + .filter(cls.app_settings_name == ldap_key).scalar() + + @classmethod + def get_app_settings(cls, cache=False): + + ret = Session.query(cls) + + if cache: + ret = ret.options(FromCache("sql_cache_short", "get_hg_settings")) + + if not ret: + raise Exception('Could not get application settings !') + settings = {} + for each in ret: + settings['rhodecode_' + each.app_settings_name] = \ + each.app_settings_value + + return settings + + @classmethod + def get_ldap_settings(cls, cache=False): + ret = Session.query(cls)\ + .filter(cls.app_settings_name.startswith('ldap_'))\ + .all() + fd = {} + for row in ret: + fd.update({row.app_settings_name:row.app_settings_value}) + + fd.update({'ldap_active':str2bool(fd.get('ldap_active'))}) + + return fd + + +class RhodeCodeUi(Base, BaseModel): __tablename__ = 'rhodecode_ui' - __table_args__ = {'useexisting':True} + __table_args__ = (UniqueConstraint('ui_key'), {'extend_existing':True}) + + HOOK_UPDATE = 'changegroup.update' + HOOK_REPO_SIZE = 'changegroup.repo_size' + HOOK_PUSH = 'pretxnchangegroup.push_logger' + HOOK_PULL = 'preoutgoing.pull_logger' + ui_id = Column("ui_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) ui_section = Column("ui_section", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) ui_key = Column("ui_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -61,9 +202,43 @@ class RhodeCodeUi(Base): ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True) -class User(Base): + @classmethod + def get_by_key(cls, key): + return Session.query(cls).filter(cls.ui_key == key) + + + @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_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_PULL])) + q = q.filter(cls.ui_section == 'hooks') + return q.all() + + @classmethod + def create_or_update_hook(cls, key, val): + new_ui = cls.get_by_key(key).scalar() 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) + Session.commit() + + +class User(Base, BaseModel): __tablename__ = 'users' - __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'extend_existing':True}) user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) username = Column("username", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -73,7 +248,8 @@ class User(Base): lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) - is_ldap = Column("is_ldap", Boolean(), nullable=False, unique=None, default=False) + ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) user_log = relationship('UserLog', cascade='all') user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all') @@ -82,6 +258,8 @@ class User(Base): user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all') repo_to_perm = relationship('RepoToPerm', primaryjoin='RepoToPerm.user_id==User.user_id', cascade='all') + group_member = relationship('UsersGroupMember', cascade='all') + @property def full_contact(self): return '%s %s <%s>' % (self.name, self.lastname, self.email) @@ -90,39 +268,63 @@ class User(Base): def short_contact(self): return '%s %s' % (self.name, self.lastname) - @property def is_admin(self): return self.admin def __repr__(self): - return "<%s('id:%s:%s')>" % (self.__class__.__name__, - self.user_id, self.username) + try: + return "<%s('id:%s:%s')>" % (self.__class__.__name__, + self.user_id, self.username) + except: + return self.__class__.__name__ @classmethod - def by_username(cls, username): - return Session.query(cls).filter(cls.username == username).one() + def by_username(cls, username, case_insensitive=False): + if case_insensitive: + return Session.query(cls).filter(cls.username.like(username)).one() + else: + return Session.query(cls).filter(cls.username == username).one() + + @classmethod + def get_by_api_key(cls, api_key): + return Session.query(cls).filter(cls.api_key == api_key).one() def update_lastlogin(self): """Update user lastlogin""" + self.last_login = datetime.datetime.now() + Session.add(self) + Session.commit() + log.debug('updated user %s lastlogin', self.username) + + @classmethod + def create(cls, form_data): + from rhodecode.lib.auth import get_crypt_password + try: - session = Session.object_session(self) - self.last_login = datetime.datetime.now() - session.add(self) - session.commit() - log.debug('updated user %s lastlogin', self.username) - except (DatabaseError,): - session.rollback() + new_user = cls() + for k, v in form_data.items(): + if k == 'password': + v = get_crypt_password(v) + setattr(new_user, k, v) + new_user.api_key = generate_api_key(form_data['username']) + Session.add(new_user) + Session.commit() + return new_user + except: + log.error(traceback.format_exc()) + Session.rollback() + raise -class UserLog(Base): +class UserLog(Base, BaseModel): __tablename__ = 'user_logs' - __table_args__ = {'useexisting':True} + __table_args__ = {'extend_existing':True} user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) - repository_id = Column("repository_id", Integer(length=None, convert_unicode=False, assert_unicode=None), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) + repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -135,24 +337,147 @@ class UserLog(Base): user = relationship('User') repository = relationship('Repository') -class Repository(Base): + +class UsersGroup(Base, BaseModel): + __tablename__ = 'users_groups' + __table_args__ = {'extend_existing':True} + + users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) + users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) + + members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined") + + def __repr__(self): + return '' % (self.users_group_name) + + @classmethod + def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): + if case_insensitive: + gr = Session.query(cls)\ + .filter(cls.users_group_name.ilike(group_name)) + else: + gr = Session.query(UsersGroup)\ + .filter(UsersGroup.users_group_name == group_name) + if cache: + gr = gr.options(FromCache("sql_cache_short", + "get_user_%s" % group_name)) + return gr.scalar() + + + @classmethod + def get(cls, users_group_id, cache=False): + users_group = Session.query(cls) + if cache: + users_group = users_group.options(FromCache("sql_cache_short", + "get_users_group_%s" % users_group_id)) + return users_group.get(users_group_id) + + @classmethod + def create(cls, form_data): + try: + new_users_group = cls() + for k, v in form_data.items(): + setattr(new_users_group, k, v) + + Session.add(new_users_group) + Session.commit() + return new_users_group + except: + log.error(traceback.format_exc()) + Session.rollback() + raise + + @classmethod + def update(cls, users_group_id, form_data): + + try: + users_group = cls.get(users_group_id, cache=False) + + for k, v in form_data.items(): + if k == 'users_group_members': + users_group.members = [] + Session.flush() + members_list = [] + if v: + for u_id in set(v): + members_list.append(UsersGroupMember( + users_group_id, + u_id)) + setattr(users_group, 'members', members_list) + setattr(users_group, k, v) + + Session.add(users_group) + Session.commit() + except: + log.error(traceback.format_exc()) + Session.rollback() + raise + + @classmethod + def delete(cls, users_group_id): + try: + + # check if this group is not assigned to repo + assigned_groups = UsersGroupRepoToPerm.query()\ + .filter(UsersGroupRepoToPerm.users_group_id == + users_group_id).all() + + if assigned_groups: + raise UsersGroupsAssignedException('Group assigned to %s' % + assigned_groups) + + users_group = cls.get(users_group_id, cache=False) + Session.delete(users_group) + Session.commit() + except: + log.error(traceback.format_exc()) + Session.rollback() + raise + + +class UsersGroupMember(Base, BaseModel): + __tablename__ = 'users_groups_members' + __table_args__ = {'extend_existing':True} + + users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) + user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) + + user = relationship('User', lazy='joined') + users_group = relationship('UsersGroup') + + def __init__(self, gr_id='', u_id=''): + self.users_group_id = gr_id + self.user_id = u_id + +class Repository(Base, BaseModel): __tablename__ = 'repositories' - __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},) + __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},) + repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) + clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None) repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg') user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) private = Column("private", 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("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) + fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None) + group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None) + user = relationship('User') fork = relationship('Repository', remote_side=repo_id) - repo_to_perm = relationship('RepoToPerm', cascade='all') + group = relationship('Group') + repo_to_perm = relationship('RepoToPerm', cascade='all', order_by='RepoToPerm.repo_to_perm_id') + users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all') stats = relationship('Statistics', cascade='all', uselist=False) - repo_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all') + followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all') logs = relationship('UserLog', cascade='all') @@ -160,9 +485,295 @@ class Repository(Base): return "<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id, self.repo_name) -class Permission(Base): + @classmethod + def by_repo_name(cls, repo_name): + q = Session.query(cls).filter(cls.repo_name == repo_name) + + q = q.options(joinedload(Repository.fork))\ + .options(joinedload(Repository.user))\ + .options(joinedload(Repository.group))\ + + return q.one() + + @classmethod + def get_repo_forks(cls, repo_id): + return Session.query(cls).filter(Repository.fork_id == repo_id) + + @classmethod + def base_path(cls): + """ + Returns base path when all repos are stored + + :param cls: + """ + q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/') + q.options(FromCache("sql_cache_short", "repository_repo_path")) + return q.one().ui_value + + @property + def just_name(self): + return self.repo_name.split(os.sep)[-1] + + @property + def groups_with_parents(self): + groups = [] + if self.group is None: + return groups + + cur_gr = self.group + groups.insert(0, cur_gr) + while 1: + gr = getattr(cur_gr, 'parent_group', None) + cur_gr = cur_gr.parent_group + if gr is None: + break + groups.insert(0, gr) + + return groups + + @property + def groups_and_repo(self): + return self.groups_with_parents, self.just_name + + @LazyProperty + def repo_path(self): + """ + Returns base full path for that repository means where it actually + exists on a filesystem + """ + q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/') + q.options(FromCache("sql_cache_short", "repository_repo_path")) + return q.one().ui_value + + @property + def repo_full_path(self): + p = [self.repo_path] + # we need to split the name by / since this is how we store the + # names in the database, but that eventually needs to be converted + # into a valid system path + p += self.repo_name.split('/') + return os.path.join(*p) + + @property + def _ui(self): + """ + Creates an db based ui object for this repository + """ + from mercurial import ui + from mercurial import config + baseui = ui.ui() + + #clean the baseui object + baseui._ocfg = config.config() + baseui._ucfg = config.config() + baseui._tcfg = config.config() + + + ret = Session.query(RhodeCodeUi)\ + .options(FromCache("sql_cache_short", "repository_repo_ui")).all() + + hg_ui = ret + for ui_ in hg_ui: + if ui_.ui_active: + log.debug('settings ui from db[%s]%s:%s', ui_.ui_section, + ui_.ui_key, ui_.ui_value) + baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value) + + return baseui + + @classmethod + def is_valid(cls, repo_name): + """ + returns True if given repo name is a valid filesystem repository + + @param cls: + @param repo_name: + """ + from rhodecode.lib.utils import is_valid_repo + + return is_valid_repo(repo_name, cls.base_path()) + + + #========================================================================== + # SCM PROPERTIES + #========================================================================== + + def get_changeset(self, rev): + return get_changeset_safe(self.scm_instance, rev) + + @property + def tip(self): + return self.get_changeset('tip') + + @property + def author(self): + return self.tip.author + + @property + def last_change(self): + return self.scm_instance.last_change + + #========================================================================== + # SCM CACHE INSTANCE + #========================================================================== + + @property + def invalidate(self): + """ + Returns Invalidation object if this repo should be invalidated + None otherwise. `cache_active = False` means that this cache + state is not valid and needs to be invalidated + """ + return Session.query(CacheInvalidation)\ + .filter(CacheInvalidation.cache_key == self.repo_name)\ + .filter(CacheInvalidation.cache_active == False)\ + .scalar() + + def set_invalidate(self): + """ + set a cache for invalidation for this instance + """ + inv = Session.query(CacheInvalidation)\ + .filter(CacheInvalidation.cache_key == self.repo_name)\ + .scalar() + + if inv is None: + inv = CacheInvalidation(self.repo_name) + inv.cache_active = True + Session.add(inv) + Session.commit() + + @LazyProperty + def scm_instance(self): + return self.__get_instance() + + @property + def scm_instance_cached(self): + @cache_region('long_term') + def _c(repo_name): + return self.__get_instance() + + # TODO: remove this trick when beaker 1.6 is released + # and have fixed this issue with not supporting unicode keys + rn = safe_str(self.repo_name) + + inv = self.invalidate + if inv is not None: + region_invalidate(_c, None, rn) + # update our cache + inv.cache_active = True + Session.add(inv) + Session.commit() + + return _c(rn) + + def __get_instance(self): + + repo_full_path = self.repo_full_path + + try: + alias = get_scm(repo_full_path)[0] + log.debug('Creating instance of %s repository', alias) + backend = get_backend(alias) + except VCSError: + log.error(traceback.format_exc()) + log.error('Perhaps this repository is in db and not in ' + 'filesystem run rescan repositories with ' + '"destroy old data " option from admin panel') + return + + if alias == 'hg': + + repo = backend(safe_str(repo_full_path), create=False, + baseui=self._ui) + #skip hidden web repository + if repo._get_hidden(): + return + else: + repo = backend(repo_full_path, create=False) + + return repo + + +class Group(Base, BaseModel): + __tablename__ = 'groups' + __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'), + CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},) + __mapper_args__ = {'order_by':'group_name'} + + group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + group_name = Column("group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None) + group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) + group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) + + parent_group = relationship('Group', remote_side=group_id) + + + def __init__(self, group_name='', parent_group=None): + self.group_name = group_name + self.parent_group = parent_group + + def __repr__(self): + return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id, + self.group_name) + + @classmethod + def url_sep(cls): + return '/' + + @property + def parents(self): + parents_recursion_limit = 5 + groups = [] + if self.parent_group is None: + return groups + cur_gr = self.parent_group + groups.insert(0, cur_gr) + cnt = 0 + while 1: + cnt += 1 + gr = getattr(cur_gr, 'parent_group', None) + cur_gr = cur_gr.parent_group + if gr is None: + break + if cnt == parents_recursion_limit: + # this will prevent accidental infinit loops + log.error('group nested more than %s' % + parents_recursion_limit) + break + + groups.insert(0, gr) + return groups + + @property + def children(self): + return Session.query(Group).filter(Group.parent_group == self) + + @property + def full_path(self): + return Group.url_sep().join([g.group_name for g in self.parents] + + [self.group_name]) + + @property + def repositories(self): + return Session.query(Repository).filter(Repository.group == self) + + @property + def repositories_recursive_count(self): + cnt = self.repositories.count() + + def children_count(group): + cnt = 0 + for child in group.children: + cnt += child.repositories.count() + cnt += children_count(child) + return cnt + + return cnt + children_count(self) + +class Permission(Base, BaseModel): __tablename__ = 'permissions' - __table_args__ = {'useexisting':True} + __table_args__ = {'extend_existing':True} permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) permission_name = Column("permission_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) permission_longname = Column("permission_longname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -171,9 +782,13 @@ class Permission(Base): return "<%s('%s:%s')>" % (self.__class__.__name__, self.permission_id, self.permission_name) -class RepoToPerm(Base): + @classmethod + def get_by_key(cls, key): + return Session.query(cls).filter(cls.permission_name == key).scalar() + +class RepoToPerm(Base, BaseModel): __tablename__ = 'repo_to_perm' - __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True}) repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) @@ -183,9 +798,9 @@ class RepoToPerm(Base): permission = relationship('Permission') repository = relationship('Repository') -class UserToPerm(Base): +class UserToPerm(Base, BaseModel): __tablename__ = 'user_to_perm' - __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'extend_existing':True}) user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) @@ -193,9 +808,120 @@ class UserToPerm(Base): user = relationship('User') permission = relationship('Permission') -class Statistics(Base): + @classmethod + def has_perm(cls, user_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + return Session.query(cls).filter(cls.user_id == user_id)\ + .filter(cls.permission == perm).scalar() is not None + + @classmethod + def grant_perm(cls, user_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + new = cls() + new.user_id = user_id + new.permission = perm + try: + Session.add(new) + Session.commit() + except: + Session.rollback() + + + @classmethod + def revoke_perm(cls, user_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + try: + Session.query(cls).filter(cls.user_id == user_id)\ + .filter(cls.permission == perm).delete() + Session.commit() + except: + Session.rollback() + +class UsersGroupRepoToPerm(Base, BaseModel): + __tablename__ = 'users_group_repo_to_perm' + __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True}) + users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) + permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) + repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) + + users_group = relationship('UsersGroup') + permission = relationship('Permission') + repository = relationship('Repository') + + def __repr__(self): + return ' %s >' % (self.users_group, self.repository) + +class UsersGroupToPerm(Base, BaseModel): + __tablename__ = 'users_group_to_perm' + users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) + permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) + + users_group = relationship('UsersGroup') + permission = relationship('Permission') + + + @classmethod + def has_perm(cls, users_group_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + return Session.query(cls).filter(cls.users_group_id == + users_group_id)\ + .filter(cls.permission == perm)\ + .scalar() is not None + + @classmethod + def grant_perm(cls, users_group_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + new = cls() + new.users_group_id = users_group_id + new.permission = perm + try: + Session.add(new) + Session.commit() + except: + Session.rollback() + + + @classmethod + def revoke_perm(cls, users_group_id, perm): + if not isinstance(perm, Permission): + raise Exception('perm needs to be an instance of Permission class') + + try: + Session.query(cls).filter(cls.users_group_id == users_group_id)\ + .filter(cls.permission == perm).delete() + Session.commit() + except: + Session.rollback() + + +class GroupToPerm(Base, BaseModel): + __tablename__ = 'group_to_perm' + __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True}) + + group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) + user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) + permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) + group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) + + user = relationship('User') + permission = relationship('Permission') + group = relationship('Group') + +class Statistics(Base, BaseModel): __tablename__ = 'statistics' - __table_args__ = (UniqueConstraint('repository_id'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('repository_id'), {'extend_existing':True}) stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) @@ -205,25 +931,31 @@ class Statistics(Base): repository = relationship('Repository', single_parent=True) -class UserFollowing(Base): +class UserFollowing(Base, BaseModel): __tablename__ = 'user_followings' __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'), UniqueConstraint('user_id', 'follows_user_id') - , {'useexisting':True}) + , {'extend_existing':True}) user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) user_id = Column("user_id", 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("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) + follows_from = Column('follows_from', 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') -class CacheInvalidation(Base): + + @classmethod + def get_repo_followers(cls, repo_id): + return Session.query(cls).filter(cls.follows_repo_id == repo_id) + +class CacheInvalidation(Base, BaseModel): __tablename__ = 'cache_invalidation' - __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True}) + __table_args__ = (UniqueConstraint('cache_key'), {'extend_existing':True}) cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) @@ -239,10 +971,9 @@ class CacheInvalidation(Base): return "<%s('%s:%s')>" % (self.__class__.__name__, self.cache_id, self.cache_key) -class DbMigrateVersion(Base): +class DbMigrateVersion(Base, BaseModel): __tablename__ = 'db_migrate_version' - __table_args__ = {'useexisting':True} - repository_id = Column('repository_id', String(255), primary_key=True) + __table_args__ = {'extend_existing':True} + repository_id = Column('repository_id', String(250), primary_key=True) repository_path = Column('repository_path', Text) version = Column('version', Integer) -