Add a table view to the repos list page

Fixes #104

data/model/legacy.py

@@ -330,29 +330,39 @@ def _list_entity_robots(entity_name):
           .where(User.robot == True, User.username ** (entity_name + '+%')))
 
 
-class _TupleWrapper(object):
-  def __init__(self, data, fields):
-    self._data = data
-    self._fields = fields
-
-  def get(self, field):
-    return self._data[self._fields.index(field.name + ':' + field.model_class.__name__)]
-
-
 class TupleSelector(object):
   """ Helper class for selecting tuples from a peewee query and easily accessing
       them as if they were objects.
   """
+  class _TupleWrapper(object):
+    def __init__(self, data, fields):
+      self._data = data
+      self._fields = fields
+
+    def get(self, field):
+      return self._data[self._fields.index(TupleSelector.tuple_reference_key(field))]
+
+  @classmethod
+  def tuple_reference_key(cls, field):
+    """ Returns a string key for referencing a field in a TupleSelector. """
+    if field._node_type == 'func':
+      return field.name + ','.join([cls.tuple_reference_key(arg) for arg in field.arguments])
+
+    if field._node_type == 'field':
+      return field.name + ':' + field.model_class.__name__
+
+    raise Exception('Unknown field type %s in TupleSelector' % field._node_type)
+
   def __init__(self, query, fields):
     self._query = query.select(*fields).tuples()
-    self._fields = [field.name + ':' + field.model_class.__name__ for field in fields]
+    self._fields = [TupleSelector.tuple_reference_key(field) for field in fields]
 
   def __iter__(self):
     return self._build_iterator()
 
   def _build_iterator(self):
     for tuple_data in self._query:
-      yield _TupleWrapper(tuple_data, self._fields)
+      yield TupleSelector._TupleWrapper(tuple_data, self._fields)
 
 
 
@@ -934,22 +944,22 @@ def get_user_teams_within_org(username, organization):
                       User.username == username)
 
 
-def get_visible_repository_count(username=None, include_public=True,
-                                 namespace=None):
-  query = _visible_repository_query(username=username,
-                                    include_public=include_public,
-                                    namespace=namespace)
-  return query.count()
-
-
 def get_visible_repositories(username=None, include_public=True, page=None,
-                             limit=None, sort=False, namespace=None, namespace_only=False):
+                             limit=None, namespace=None, namespace_only=False,
+                             include_actions=False, include_latest_tag=False):
+
+  fields = [Repository.name, Repository.id, Repository.description, Visibility.name,
+            Namespace.username]
+
+  if include_actions:
+    fields.append(fn.Max(RepositoryActionCount.count))
+
+  if include_latest_tag:
+    fields.append(fn.Max(RepositoryTag.lifetime_start_ts))
+
   query = _visible_repository_query(username=username, include_public=include_public, page=page,
                                     limit=limit, namespace=namespace,
-                                    select_models=[Repository, Namespace, Visibility])
-
-  if sort:
-    query = query.order_by(Repository.id.desc())
+                                    select_models=fields)
 
   if limit:
     query = query.limit(limit)
@@ -957,7 +967,24 @@ def get_visible_repositories(username=None, include_public=True, page=None,
   if namespace and namespace_only:
     query = query.where(Namespace.username == namespace)
 
-  return query
+  if include_actions:
+    # Filter the join to recent entries only.
+    last_week = datetime.now() - timedelta(weeks=1)
+    join_query = ((RepositoryActionCount.repository == Repository.id) &
+                  (RepositoryActionCount.date >= last_week))
+
+    query = (query.switch(Repository)
+                  .join(RepositoryActionCount, JOIN_LEFT_OUTER, on=join_query)
+                  .group_by(RepositoryActionCount.repository, Repository.name, Repository.id,
+                            Repository.description, Visibility.name, Namespace.username))
+
+  if include_latest_tag:
+    query = (query.switch(Repository)
+                  .join(RepositoryTag, JOIN_LEFT_OUTER)
+                  .group_by(RepositoryTag.repository, Repository.name, Repository.id,
+                            Repository.description, Visibility.name, Namespace.username))
+
+  return TupleSelector(query, fields)
 
 
 def _visible_repository_query(username=None, include_public=True, limit=None,
@@ -1101,7 +1128,7 @@ def get_matching_repositories(repo_term, username=None, limit=10, include_public
   namespace_term = repo_term
   name_term = repo_term
 
-  visible = get_visible_repositories(username, include_public=include_public)
+  visible = _visible_repository_query(username, include_public=include_public)
 
   search_clauses = (Repository.name ** ('%' + name_term + '%') |
                     Namespace.username ** ('%' + namespace_term + '%'))