def get_matching_robots(name_prefix, username, limit=10):
admined_orgs = (_basequery.get_user_organizations(username).switch(
Team).join(TeamRole).where(TeamRole.name == "admin"))
prefix_checks = False
for org in admined_orgs:
org_search = prefix_search(User.username,
org.username + "+" + name_prefix)
prefix_checks = prefix_checks | org_search
user_search = prefix_search(User.username, username + "+" + name_prefix)
prefix_checks = prefix_checks | user_search
return User.select().where(prefix_checks).limit(limit)
def _get_matching_users(username_prefix,
robot_namespace=None,
organization=None,
limit=20,
exact_matches_only=False):
user_search = prefix_search(User.username, username_prefix)
if exact_matches_only:
user_search = User.username == username_prefix
direct_user_query = user_search & (User.organization
== False) & (User.robot == False)
if robot_namespace:
robot_prefix = format_robot_username(robot_namespace, username_prefix)
robot_search = prefix_search(User.username, robot_prefix)
direct_user_query = (robot_search &
(User.robot == True)) | direct_user_query
query = (User.select(User.id, User.username,
User.email, User.robot).group_by(
User.id, User.username, User.email,
User.robot).where(direct_user_query))
if organization:
query = (query.select(User.id, User.username, User.email, User.robot,
fn.Sum(Team.id)).join(
TeamMember, JOIN.LEFT_OUTER).join(
Team,
JOIN.LEFT_OUTER,
on=((Team.id == TeamMember.team) &
(Team.organization == organization)),
).order_by(User.robot.desc()))
class MatchingUserResult(object):
def __init__(self, *args):
self.id = args[0]
self.username = args[1]
self.email = args[2]
self.robot = args[3]
if organization:
self.is_org_member = args[3] != None
else:
self.is_org_member = None
return (MatchingUserResult(*args) for args in query.tuples().limit(limit))
def get_matching_user_teams(team_prefix, user_obj, limit=10):
team_prefix_search = prefix_search(Team.name, team_prefix)
query = (Team.select(Team.id.distinct(),
Team).join(User).switch(Team).join(TeamMember).where(
TeamMember.user == user_obj,
team_prefix_search).limit(limit))
return query
def list_manifest_labels(manifest_id, prefix_filter=None):
""" Lists all labels found on the given manifest, with an optional filter by key prefix. """
query = (Label.select(Label, MediaType).join(MediaType).switch(Label).join(
LabelSourceType).switch(Label).join(ManifestLabel).where(
ManifestLabel.manifest == manifest_id))
if prefix_filter is not None:
query = query.where(prefix_search(Label.key, prefix_filter))
return query
def list_manifest_labels(tag_manifest, prefix_filter=None):
""" Lists all labels found on the given tag manifest. """
query = (Label.select(Label, MediaType).join(MediaType).switch(Label).join(
LabelSourceType).switch(Label).join(TagManifestLabel).where(
TagManifestLabel.annotated == tag_manifest))
if prefix_filter is not None:
query = query.where(prefix_search(Label.key, prefix_filter))
return query
def get_matching_user_namespaces(namespace_prefix, username, limit=10):
namespace_user = get_namespace_user(username)
namespace_user_id = namespace_user.id if namespace_user is not None else None
namespace_search = prefix_search(Namespace.username, namespace_prefix)
base_query = (Namespace.select().distinct().join(
Repository, on=(Repository.namespace_user == Namespace.id)).join(
RepositoryPermission, JOIN.LEFT_OUTER).where(namespace_search))
return _basequery.filter_to_repos_for_user(base_query,
namespace_user_id).limit(limit)
def get_matching_admined_teams(team_prefix, user_obj, limit=10):
team_prefix_search = prefix_search(Team.name, team_prefix)
admined_orgs = (_basequery.get_user_organizations(
user_obj.username).switch(Team).join(TeamRole).where(
TeamRole.name == "admin"))
query = (Team.select(Team.id.distinct(),
Team).join(User).switch(Team).join(TeamMember).where(
team_prefix_search, Team.organization <<
(admined_orgs)).limit(limit))
return query
def match_prefix(self, query):
return prefix_search(self, query)
def get_matching_teams(team_prefix, organization):
team_prefix_search = prefix_search(Team.name, team_prefix)
query = Team.select().where(team_prefix_search,
Team.organization == organization)
return query.limit(10)
