Made a stupid assumption about when users belonged to an organization, now paying for my terrible ways.

data/model.py

@@ -222,13 +222,35 @@ def get_user(username):
 
 
 def get_matching_teams(team_prefix, organization):  
-  query = Team.select().where(Team.name ** (team_prefix + '%'), Team.organization == organization)
+  query = Team.select().where(Team.name ** (team_prefix + '%'),
+                              Team.organization == organization)
   return list(query.limit(10))
 
 
-def get_matching_users(username_prefix):
-  query = User.select().where(User.username ** (username_prefix + '%'), User.organization == False)
-  return list(query.limit(10))
+def get_matching_users(username_prefix, organization=None):
+  Org = User.alias()
+  users_no_orgs = (User.username ** (username_prefix + '%') & 
+                  (User.organization == False))
+  query = User.select(User.username, Org.username).where(users_no_orgs)
+
+  if organization:
+    with_team = query.join(TeamMember, JOIN_LEFT_OUTER).join(Team,
+                                                             JOIN_LEFT_OUTER)
+    with_org = with_team.join(Org, JOIN_LEFT_OUTER,
+                              on=(Org.id == Team.organization))
+    query = with_org.where((Org.id == organization) | (Org.id >> None))
+
+
+  class MatchingUserResult(object):
+    def __init__(self, *args):
+      self.username = args[0]
+      if organization:
+        self.is_org_member = (args[1] == organization.username)
+      else:
+        self.is_org_member = False
+
+
+  return (MatchingUserResult(*args) for args in query.tuples().limit(10))
 
 
 def verify_user(username, password):
@@ -264,10 +286,12 @@ def get_organization(name):
 
 def get_organization_team(orgname, teamname):
   joined = Team.select().join(User)
-  query = joined.where(Team.name == teamname, User.organization == True, User.username == orgname).limit(1)
+  query = joined.where(Team.name == teamname, User.organization == True,
+                       User.username == orgname).limit(1)
   result = list(query)
   if not result:
-    raise InvalidTeamException('Team does not exist: %s/%s', orgname, teamname)
+    raise InvalidTeamException('Team does not exist: %s/%s', orgname,
+                               teamname)
 
   return result[0]
 
@@ -278,6 +302,12 @@ def get_organization_team_members(teamid):
   return query
 
 
+def get_organization_member_set(orgname):
+  Org = User.alias()
+  user_teams = User.select(User.username).join(TeamMember).join(Team)
+  with_org = user_teams.join(Org, on=(Org.username == orgname))
+  return {user.username for user in with_org}
+
 
 def get_teams_within_org(organization):
   return Team.select().where(Team.organization == organization)
@@ -390,14 +420,15 @@ def get_org_wide_permissions(user):
 
 
 def get_all_repo_teams(namespace_name, repository_name):
-  select = RepositoryPermission.select(Team.name.alias('team_name'), Role.name,
-                                       RepositoryPermission)
+  select = RepositoryPermission.select(Team.name.alias('team_name'),
+                                       Role.name, RepositoryPermission)
   with_team = select.join(Team)
   with_role = with_team.switch(RepositoryPermission).join(Role)
   with_repo = with_role.switch(RepositoryPermission).join(Repository)
   return with_repo.where(Repository.namespace == namespace_name,
                          Repository.name == repository_name)
 
+
 def get_all_repo_users(namespace_name, repository_name):
   select = RepositoryPermission.select(User.username, Role.name,
                                        RepositoryPermission)