kallithea Changeset - 24239f8ea946

Changeset - 24239f8ea946

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Mads Kiilerich - 10 years ago 2015-07-20 15:11:42
madski@unity3d.com

db: cleanup of repo group choices - better handling of root and better sorting

groups_choices always get a groups list so there is no reason have code for
creating a list.

All the responsibility of creating the tuples is moved to _generate_choice -
also for the magic top level entries.

Also sort the choices by all path elements - not just the top level element.

1 file changed with 14 insertions and 14 deletions:

kallithea/model/db.py

0 comments (0 inline, 0 general)

kallithea/model/db.py

➞

Show inline comments

@@ @@ -1467,113 +1467,113 @@ class Repository(Base, BaseModel): @@
         backend = get_backend(alias)
         if alias == 'hg':
             repo = backend(safe_str(repo_full_path), create=False,
                            baseui=self._ui)
         else:
             repo = backend(repo_full_path, create=False)
         return repo
     def __json__(self):
         return dict(landing_rev = self.landing_rev)
 class RepoGroup(Base, BaseModel):
     __tablename__ = 'groups'
     __table_args__ = (
         UniqueConstraint('group_name', 'group_parent_id'),
         CheckConstraint('group_id != group_parent_id'),
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
+    )
     __mapper_args__ = {'order_by': 'group_name'}
     SEP = ' &raquo; '
     group_id = Column(Integer(), nullable=False, unique=True, primary_key=True)
     group_name = Column(String(255, convert_unicode=False), nullable=False, unique=True, default=None)
     group_parent_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
     group_description = Column(String(10000, convert_unicode=False), nullable=True, unique=None, default=None)
     enable_locking = Column(Boolean(), nullable=False, unique=None, default=False)
     user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
     users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
     parent_group = relationship('RepoGroup', remote_side=group_id)
     user = relationship('User')
     def __init__(self, group_name='', parent_group=None):
         self.group_name = group_name
         self.parent_group = parent_group
     def __unicode__(self):
         return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
                                       self.group_name)
     @classmethod
     def _generate_choice(cls, repo_group):
         from webhelpers.html import literal as _literal
         _name = lambda k: _literal(cls.SEP.join(k))
         return repo_group.group_id, _name(repo_group.full_path_splitted)
         """Return tuple with group_id as unicode string and name as html literal"""
         from webhelpers.html import literal
         if repo_group is None:
             return (u'-1', u'-- %s --' % _('top level'))
         return unicode(repo_group.group_id), literal(cls.SEP.join(repo_group.full_path_splitted))
     @classmethod
     def groups_choices(cls, groups=None, show_empty_group=True):
         if not groups:
             groups = cls.query().all()
         repo_groups = []
     def groups_choices(cls, groups, show_empty_group=True):
         """Return tuples with group_id as unicode string and name as html literal."""
         if show_empty_group:
             repo_groups = [('-1', u'-- %s --' % _('Top level'))]
         repo_groups.extend([cls._generate_choice(x) for x in groups])
         repo_groups = sorted(repo_groups, key=lambda t: t[1].split(cls.SEP)[0])
         return repo_groups
             groups = list(groups)
             groups.append(None)
         choices = [cls._generate_choice(g) for g in groups]
         return sorted(choices, key=lambda c: c[1].split(cls.SEP))
     @classmethod
     def url_sep(cls):
         return URL_SEP
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
             gr = cls.query()\
                 .filter(cls.group_name.ilike(group_name))
         else:
             gr = cls.query()\
                 .filter(cls.group_name == group_name)
         if cache:
             gr = gr.options(FromCache(
                             "sql_cache_short",
                             "get_group_%s" % _hash_key(group_name)
+                            )
+            )
         return gr.scalar()
     @property
     def parents(self):
         parents_recursion_limit = 10
         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 infinite loops
                 log.error(('more than %s parents found for group %s, stopping '
                            'recursive parent fetching' % (parents_recursion_limit, self)))
                 break
             groups.insert(0, gr)
         return groups
     @property
     def children(self):
         return RepoGroup.query().filter(RepoGroup.parent_group == self)

0 comments (0 inline, 0 general)