def get(self, request, organization):
queryset = OrganizationMember.objects.filter(
Q(user__is_active=True) | Q(user__isnull=True),
organization=organization,
).select_related('user').order_by('email', 'user__email')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'email':
queryset = queryset.filter(
Q(email__in=value) | Q(user__email__in=value)
| Q(user__emails__email__in=value))
elif key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(email__icontains=value)
| Q(user__email__icontains=value)
| Q(user__name__icontains=value))
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request):
queryset = User.objects.distinct()
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in tokens.iteritems():
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(username__icontains=value)
| Q(email__icontains=value))
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'email':
queryset = queryset.filter(in_iexact('email', value))
elif key == 'username':
queryset = queryset.filter(in_iexact('username', value))
status = request.GET.get('status')
if status == 'active':
queryset = queryset.filter(is_active=True, )
elif status == 'disabled':
queryset = queryset.filter(is_active=False, )
order_by = '-date_joined'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
"""
List an Organization's Teams
````````````````````````````
Return a list of teams bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the teams should be listed.
:param string detailed: Specify "0" to return team details that do not include projects
:auth: required
"""
# TODO(dcramer): this should be system-wide default for organization
# based endpoints
if request.auth and hasattr(request.auth, "project"):
return Response(status=403)
queryset = Team.objects.filter(
organization=organization, status=TeamStatus.VISIBLE
).order_by("slug")
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in tokens.items():
if key == "hasExternalTeams":
has_external_teams = "true" in value
if has_external_teams:
queryset = queryset.filter(
actor_id__in=ExternalActor.objects.filter(
organization=organization
).values_list("actor_id")
)
else:
queryset = queryset.exclude(
actor_id__in=ExternalActor.objects.filter(
organization=organization
).values_list("actor_id")
)
elif key == "query":
value = " ".join(value)
queryset = queryset.filter(Q(name__icontains=value) | Q(slug__icontains=value))
elif key == "slug":
queryset = queryset.filter(slug__in=value)
else:
queryset = queryset.none()
is_detailed = request.GET.get("detailed", "1") != "0"
expand = ["projects", "externalTeams"] if is_detailed else []
return self.paginate(
request=request,
queryset=queryset,
order_by="slug",
on_results=lambda x: serialize(x, request.user, TeamSerializer(expand=expand)),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
List saved queries for organization
"""
if not self.has_feature(organization, request):
return self.respond(status=404)
queryset = (
DiscoverSavedQuery.objects.filter(organization=organization)
.prefetch_related("projects")
.order_by("name")
)
query = request.query_params.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "name" or key == "query":
value = " ".join(value)
queryset = queryset.filter(name__icontains=value)
elif key == "version":
value = " ".join(value)
queryset = queryset.filter(version=value)
else:
queryset = queryset.none()
saved_queries = list(queryset.all())
return Response(serialize(saved_queries), status=200)
def get(self, request):
queryset = User.objects.distinct()
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(username__icontains=value) | Q(email__icontains=value)
)
elif key == "name":
queryset = queryset.filter(in_iexact("name", value))
elif key == "email":
queryset = queryset.filter(in_iexact("email", value))
elif key == "username":
queryset = queryset.filter(in_iexact("username", value))
status = request.GET.get("status")
if status == "active":
queryset = queryset.filter(is_active=True)
elif status == "disabled":
queryset = queryset.filter(is_active=False)
order_by = "-date_joined"
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def test_tokenize_query_only_keyed_fields():
tests = [
("a:a", {"a": ["a"]}),
("(a:a AND b:b)", {"a": ["a"], "b": ["b"]}),
("( a:a AND (b:b OR c:c))", {"a": ["a"], "b": ["b"], "c": ["c"]}),
("( a:a AND (b:b OR c:c ) )", {"a": ["a"], "b": ["b"], "c": ["c"]}),
(
"(x y a:a AND (b:b OR c:c) z)",
{"a": ["a"], "b": ["b"], "c": ["c"], "query": ["x", "y", "z"]},
),
(
"((x y)) a:a AND (b:b OR c:c) z)",
{"a": ["a"], "b": ["b"], "c": ["c"], "query": ["x", "y", "z"]},
),
(
"((x y)) a():>a AND (!b:b OR c():<c) z)",
{"a()": [">a"], "!b": ["b"], "c()": ["<c"], "query": ["x", "y", "z"]},
),
('a:"\\"a\\""', {"a": ['\\"a\\"']}),
(
'a:"i \\" quote" b:"b\\"bb" c:"cc"',
{"a": ['i \\" quote'], "b": ['b\\"bb'], "c": ["cc"]},
),
]
for test in tests:
assert tokenize_query(test[0]) == test[1], test[0]
def get(self, request, organization):
queryset = OrganizationMember.objects.filter(
Q(user__is_active=True) | Q(user__isnull=True),
organization=organization,
).select_related('user').order_by('email', 'user__email')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'email':
queryset = queryset.filter(Q(email__in=value) |
Q(user__email__in=value) |
Q(user__emails__email__in=value))
elif key == 'scope':
queryset = queryset.filter(role__in=[r.id for r in roles.with_any_scope(value)])
elif key == 'role':
queryset = queryset.filter(role__in=value)
elif key == 'query':
value = ' '.join(value)
queryset = queryset.filter(Q(email__icontains=value) |
Q(user__email__icontains=value) |
Q(user__name__icontains=value))
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
List saved queries for organization
"""
if not self.has_feature(organization, request):
return self.respond(status=404)
queryset = (DiscoverSavedQuery.objects.filter(
organization=organization).select_related(
"created_by").prefetch_related("projects").extra(
select={"lower_name": "lower(name)"}))
query = request.query_params.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "name" or key == "query":
value = " ".join(value)
queryset = queryset.filter(name__icontains=value)
elif key == "version":
value = " ".join(value)
queryset = queryset.filter(version=value)
else:
queryset = queryset.none()
sort_by = request.query_params.get("sortBy")
if sort_by in ("name", "-name"):
order_by = "-lower_name" if sort_by.startswith(
"-") else "lower_name"
elif sort_by in ("dateCreated", "-dateCreated"):
order_by = "-date_created" if sort_by.startswith(
"-") else "date_created"
elif sort_by in ("dateUpdated", "-dateUpdated"):
order_by = "-date_updated" if sort_by.startswith(
"-") else "date_updated"
elif sort_by == "myqueries":
order_by = [
Case(When(created_by_id=request.user.id, then=-1),
default="created_by_id"),
"lower_name",
]
else:
order_by = "lower_name"
if not isinstance(order_by, list):
order_by = [order_by]
queryset = queryset.order_by(*order_by)
# Old discover expects all queries and uses this parameter.
if request.query_params.get("all") == "1":
saved_queries = list(queryset.all())
return Response(serialize(saved_queries), status=200)
def data_fn(offset, limit):
return list(queryset[offset:offset + limit])
return self.paginate(
request=request,
paginator=GenericOffsetPaginator(data_fn=data_fn),
on_results=lambda x: serialize(x, request.user),
default_per_page=25,
)
def get(self, request):
"""
List your Projects
``````````````````
Return a list of projects available to the authenticated
session.
:auth: required
"""
queryset = Project.objects.select_related('organization').distinct()
status = request.GET.get('status', 'active')
if status == 'active':
queryset = queryset.filter(status=ProjectStatus.VISIBLE, )
elif status == 'deleted':
queryset = queryset.exclude(status=ProjectStatus.VISIBLE, )
elif status:
queryset = queryset.none()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(id=request.auth.project_id, )
elif request.auth.organization is not None:
queryset = queryset.filter(
organization=request.auth.organization.id, )
else:
queryset = queryset.none()
elif not request.is_superuser():
queryset = queryset.filter(
team__organizationmember__user=request.user, )
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
elif key == 'slug':
queryset = queryset.filter(in_iexact('slug', value))
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'platform':
queryset = queryset.filter(
id__in=ProjectPlatform.objects.filter(
platform__in=value, ).values('project_id'))
elif key == 'id':
queryset = queryset.filter(id__in=value)
return self.paginate(
request=request,
queryset=queryset,
order_by='-date_added',
on_results=lambda x: serialize(
x, request.user, ProjectWithOrganizationSerializer()),
paginator_cls=DateTimePaginator,
)
def get(self, request, organization):
"""
Retrieve monitors for an organization
`````````````````````````````````````
:pparam string organization_slug: the slug of the organization
:auth: required
"""
if not features.has("organizations:monitors", organization, actor=request.user):
raise ResourceDoesNotExist
try:
filter_params = self.get_filter_params(request, organization, date_filter_optional=True)
except NoProjects:
return self.respond([])
queryset = Monitor.objects.filter(
organization_id=organization.id, project_id__in=filter_params["project_id"]
).exclude(status__in=[MonitorStatus.PENDING_DELETION, MonitorStatus.DELETION_IN_PROGRESS])
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in tokens.items():
if key == "query":
value = " ".join(value)
queryset = queryset.filter(Q(name__icontains=value) | Q(id__iexact=value))
elif key == "id":
queryset = queryset.filter(in_iexact("id", value))
elif key == "name":
queryset = queryset.filter(in_iexact("name", value))
elif key == "status":
try:
queryset = queryset.filter(
status__in=map_value_to_constant(MonitorStatus, value)
)
except ValueError:
queryset = queryset.none()
elif key == "type":
try:
queryset = queryset.filter(
status__in=map_value_to_constant(MonitorType, value)
)
except ValueError:
queryset = queryset.none()
else:
queryset = queryset.none()
queryset = queryset.extra(
select={"is_error": f"sentry_monitor.status = {MonitorStatus.ERROR}"}
)
return self.paginate(
request=request,
queryset=queryset,
order_by=("-is_error", "-name"),
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request):
queryset = User.objects.distinct()
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(username__icontains=value) |
Q(email__icontains=value) | Q(emails__email__icontains=value)
)
elif key == 'id':
queryset = queryset.filter(
id__in=[request.user.id if v == 'me' else v for v in value],
)
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'email':
queryset = queryset.filter(in_iexact('email', value))
elif key == 'username':
queryset = queryset.filter(in_iexact('username', value))
elif key == 'is':
for v in value:
if v == 'superuser':
queryset = queryset.filter(is_superuser=True)
else:
queryset = queryset.none()
elif key == 'permission':
queryset = queryset.filter(
userpermission__permission__in=[v.lower() for v in value],
)
else:
queryset = queryset.none()
status = request.GET.get('status')
if status == 'active':
queryset = queryset.filter(
is_active=True,
)
elif status == 'disabled':
queryset = queryset.filter(
is_active=False,
)
order_by = '-date_joined'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
"""
List an Organization's Teams
````````````````````````````
Return a list of teams bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the teams should be listed.
:param string detailed: Specify "0" to return team details that do not include projects
:param string is_not_member: Specify "1" to *only* return team details of teams that user is not a member of
:auth: required
"""
# TODO(dcramer): this should be system-wide default for organization
# based endpoints
if request.auth and hasattr(request.auth, "project"):
return Response(status=403)
with sentry_sdk.start_span(op="PERF: OrgTeam.get - filter"):
queryset = Team.objects.filter(
organization=organization,
status=TeamStatus.VISIBLE).order_by("slug")
if request.GET.get("is_not_member", "0") == "1":
user_teams = Team.objects.get_for_user(organization=organization,
user=request.user)
queryset = queryset.exclude(id__in=[ut.id for ut in user_teams])
query = request.GET.get("query")
with sentry_sdk.start_span(op="PERF: OrgTeam.get - tokenize"):
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value)
| Q(slug__icontains=value))
else:
queryset = queryset.none()
is_detailed = request.GET.get("detailed", "1") != "0"
with sentry_sdk.start_span(op="PERF: OrgTeam.get - serialize"):
serializer = (team_serializers.TeamWithProjectsSerializer
if is_detailed else team_serializers.TeamSerializer)
return self.paginate(
request=request,
queryset=queryset,
order_by="slug",
on_results=lambda x: serialize(x, request.user, serializer()),
paginator_cls=OffsetPaginator,
)
def get(self, request: Request) -> Response:
queryset = User.objects.distinct()
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in tokens.items():
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value)
| Q(username__icontains=value)
| Q(email__icontains=value)
| Q(emails__email__icontains=value)
)
elif key == "id":
queryset = queryset.filter(
id__in=[request.user.id if v == "me" else v for v in value]
)
elif key == "name":
queryset = queryset.filter(in_iexact("name", value))
elif key == "email":
queryset = queryset.filter(in_iexact("email", value))
elif key == "username":
queryset = queryset.filter(in_iexact("username", value))
elif key == "is":
for v in value:
if v == "superuser":
queryset = queryset.filter(is_superuser=True)
else:
queryset = queryset.none()
elif key == "permission":
queryset = queryset.filter(
userpermission__permission__in=[v.lower() for v in value]
)
else:
queryset = queryset.none()
status = request.GET.get("status")
if status == "active":
queryset = queryset.filter(is_active=True)
elif status == "disabled":
queryset = queryset.filter(is_active=False)
order_by = "-date_joined"
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request):
queryset = User.objects.distinct()
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(username__icontains=value)
| Q(email__icontains=value)
| Q(emails__email__icontains=value))
elif key == 'id':
queryset = queryset.filter(id__in=[
request.user.id if v == 'me' else v for v in value
], )
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'email':
queryset = queryset.filter(in_iexact('email', value))
elif key == 'username':
queryset = queryset.filter(in_iexact('username', value))
elif key == 'is':
for v in value:
if v == 'superuser':
queryset = queryset.filter(is_superuser=True)
else:
queryset = queryset.none()
elif key == 'permission':
queryset = queryset.filter(userpermission__permission__in=[
v.lower() for v in value
], )
else:
queryset = queryset.none()
status = request.GET.get('status')
if status == 'active':
queryset = queryset.filter(is_active=True, )
elif status == 'disabled':
queryset = queryset.filter(is_active=False, )
order_by = '-date_joined'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def test_tokenize_query_only_keyed_fields():
tests = [
("a:a", {
"a": ["a"]
}),
("(a:a AND b:b)", {
"a": ["a"],
"b": ["b"]
}),
("( a:a AND (b:b OR c:c))", {
"a": ["a"],
"b": ["b"],
"c": ["c"]
}),
("( a:a AND (b:b OR c:c ) )", {
"a": ["a"],
"b": ["b"],
"c": ["c"]
}),
(
"(x y a:a AND (b:b OR c:c) z)",
{
"a": ["a"],
"b": ["b"],
"c": ["c"],
"query": ["x", "y", "z"]
},
),
(
"((x y)) a:a AND (b:b OR c:c) z)",
{
"a": ["a"],
"b": ["b"],
"c": ["c"],
"query": ["x", "y", "z"]
},
),
(
"((x y)) a():>a AND (!b:b OR c():<c) z)",
{
"a()": [">a"],
"!b": ["b"],
"c()": ["<c"],
"query": ["x", "y", "z"]
},
),
]
for test in tests:
assert tokenize_query(test[0]) == test[1], test[0]
def get(self, request, organization):
"""
List saved queries for organization
"""
if not self.has_feature(organization, request):
return self.respond(status=404)
queryset = DiscoverSavedQuery.objects.filter(
organization=organization).prefetch_related("projects")
query = request.query_params.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "name" or key == "query":
value = " ".join(value)
queryset = queryset.filter(name__icontains=value)
elif key == "version":
value = " ".join(value)
queryset = queryset.filter(version=value)
else:
queryset = queryset.none()
sort_by = request.query_params.get("sortBy")
if sort_by in ("name", "-name"):
order_by = sort_by
paginator_cls = OffsetPaginator
elif sort_by in ("dateCreated", "-dateCreated"):
order_by = "-date_created" if sort_by.startswith(
"-") else "date_created"
paginator_cls = DateTimePaginator
elif sort_by in ("dateUpdated", "-dateUpdated"):
order_by = "-date_updated" if sort_by.startswith(
"-") else "date_updated"
paginator_cls = DateTimePaginator
else:
order_by = "name"
paginator_cls = OffsetPaginator
# Old discover expects all queries and uses this parameter.
if request.query_params.get("all") == "1":
saved_queries = list(queryset.all())
return Response(serialize(saved_queries), status=200)
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
paginator_cls=paginator_cls,
on_results=lambda x: serialize(x, request.user),
default_per_page=25,
)
def get(self, request):
queryset = User.objects.distinct()
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) |
Q(username__icontains=value) |
Q(email__icontains=value)
)
elif key == 'name':
queryset = queryset.filter(
in_iexact('name', value)
)
elif key == 'email':
queryset = queryset.filter(
in_iexact('email', value)
)
elif key == 'username':
queryset = queryset.filter(
in_iexact('username', value)
)
status = request.GET.get('status')
if status == 'active':
queryset = queryset.filter(
is_active=True,
)
elif status == 'disabled':
queryset = queryset.filter(
is_active=False,
)
order_by = '-date_joined'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
"""
List an Organization's Teams
````````````````````````````
Return a list of teams bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the teams should be listed.
:param string detailed: Specify "0" to return team details that do not include projects
:auth: required
"""
# TODO(dcramer): this should be system-wide default for organization
# based endpoints
if request.auth and hasattr(request.auth, 'project'):
return Response(status=403)
queryset = Team.objects.filter(
organization=organization,
status=TeamStatus.VISIBLE,
).order_by('slug')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
else:
queryset = queryset.none()
is_detailed = request.GET.get('detailed', '1') != '0'
serializer = team_serializers.TeamWithProjectsSerializer if is_detailed else team_serializers.TeamSerializer
return self.paginate(
request=request,
queryset=queryset,
order_by='slug',
on_results=lambda x: serialize(x, request.user, serializer()),
paginator_cls=OffsetPaginator,
)
def get(self, request, project, event_id):
"""
Retrieve attachments for an event
`````````````````````````````````
:pparam string organization_slug: the slug of the organization the
issues belong to.
:pparam string project_slug: the slug of the project the event
belongs to.
:pparam string event_id: the id of the event.
:auth: required
"""
if not features.has("organizations:event-attachments",
project.organization,
actor=request.user):
return self.respond(status=404)
event = eventstore.get_event_by_id(project.id, event_id)
if event is None:
return self.respond({"detail": "Event not found"}, status=404)
queryset = EventAttachment.objects.filter(
project_id=project.id,
event_id=event.event_id).select_related("file")
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(name__icontains=value)
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
order_by="name",
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
queryset = OrganizationMember.objects.filter(
Q(user__is_active=True) | Q(user__isnull=True),
organization=organization,
).select_related('user').order_by('email', 'user__email')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'email':
queryset = queryset.filter(
Q(user__email__in=value) | Q(
user__emails__email__in=value)
)
return self.paginate(
request=request,
queryset=queryset,
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
queryset = (OrganizationMember.objects.filter(
Q(user__is_active=True) | Q(user__isnull=True),
organization=organization,
invite_status=InviteStatus.APPROVED.value,
).select_related("user").order_by("email", "user__email"))
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "email":
queryset = queryset.filter(
Q(email__in=value)
| Q(user__email__in=value)
| Q(user__emails__email__in=value))
elif key == "scope":
queryset = queryset.filter(
role__in=[r.id for r in roles.with_any_scope(value)])
elif key == "role":
queryset = queryset.filter(role__in=value)
elif key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(email__icontains=value)
| Q(user__email__icontains=value)
| Q(user__name__icontains=value))
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
List an Organization's Teams
````````````````````````````
Return a list of teams bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the teams should be listed.
:auth: required
"""
# TODO(dcramer): this should be system-wide default for organization
# based endpoints
if request.auth and hasattr(request.auth, 'project'):
return Response(status=403)
queryset = Team.objects.filter(
organization=organization,
status=TeamStatus.VISIBLE,
).order_by('slug')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(Q(name__icontains=value) | Q(slug__icontains=value))
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
order_by='slug',
on_results=lambda x: serialize(x, request.user, TeamWithProjectsSerializer()),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
Retrieve monitors for an organization
`````````````````````````````````````
:pparam string organization_slug: the slug of the organization
:auth: required
"""
if not features.has(
'organizations:monitors', organization, actor=request.user):
raise ResourceDoesNotExist
try:
filter_params = self.get_filter_params(
request,
organization,
date_filter_optional=True,
)
except NoProjects:
return self.respond([])
except OrganizationEventsError as exc:
return self.respond({'detail': exc.message}, status=400)
queryset = Monitor.objects.filter(
organization_id=organization.id,
project_id__in=filter_params['project_id'],
)
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(id__iexact=value))
elif key == 'id':
queryset = queryset.filter(in_iexact('id', value))
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'status':
try:
queryset = queryset.filter(
status__in=map_value_to_constant(
MonitorStatus, value))
except ValueError:
queryset = queryset.none()
elif key == 'type':
try:
queryset = queryset.filter(
status__in=map_value_to_constant(
MonitorType, value))
except ValueError:
queryset = queryset.none()
elif key == 'id':
queryset = queryset.filter(id__in=value)
else:
queryset = queryset.none()
queryset = queryset.extra(select={
'is_error':
'sentry_monitor.status = %s' % (MonitorStatus.ERROR, ),
}, )
return self.paginate(
request=request,
queryset=queryset,
order_by=('-is_error', '-name'),
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request):
"""
List your Projects
``````````````````
Return a list of projects available to the authenticated
session.
:auth: required
"""
queryset = Project.objects.select_related("organization").distinct()
status = request.GET.get("status", "active")
if status == "active":
queryset = queryset.filter(status=ProjectStatus.VISIBLE)
elif status == "deleted":
queryset = queryset.exclude(status=ProjectStatus.VISIBLE)
elif status:
queryset = queryset.none()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, "project"):
queryset = queryset.filter(id=request.auth.project_id)
elif request.auth.organization is not None:
queryset = queryset.filter(
organization=request.auth.organization.id)
else:
queryset = queryset.none()
elif not (is_active_superuser(request)
and request.GET.get("show") == "all"):
if request.user.is_sentry_app:
queryset = SentryAppInstallationToken.get_projects(
request.auth)
else:
queryset = queryset.filter(
teams__organizationmember__user=request.user)
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
elif key == "slug":
queryset = queryset.filter(in_iexact("slug", value))
elif key == "name":
queryset = queryset.filter(in_iexact("name", value))
elif key == "platform":
queryset = queryset.filter(
id__in=ProjectPlatform.objects.filter(
platform__in=value).values("project_id"))
elif key == "id":
queryset = queryset.filter(id__in=value)
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
order_by="-date_added",
on_results=lambda x: serialize(
x, request.user, ProjectWithOrganizationSerializer()),
paginator_cls=DateTimePaginator,
)
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool owner: restrict results to organizations in which you are
an organization owner
:auth: required
"""
owner_only = request.GET.get("owner") in ("1", "true")
queryset = Organization.objects.distinct()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, "project"):
queryset = queryset.filter(
id=request.auth.project.organization_id)
elif request.auth.organization is not None:
queryset = queryset.filter(id=request.auth.organization.id)
elif owner_only:
# This is used when closing an account
queryset = queryset.filter(
member_set__role=roles.get_top_dog().id,
member_set__user=request.user,
status=OrganizationStatus.VISIBLE,
)
org_results = []
for org in sorted(queryset, key=lambda x: x.name):
# O(N) query
org_results.append({
"organization": serialize(org),
"singleOwner": org.has_single_owner()
})
return Response(org_results)
elif not (is_active_superuser(request)
and request.GET.get("show") == "all"):
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
user=request.user).values("organization"))
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value)
| Q(slug__icontains=value)
| Q(members__email__iexact=value))
elif key == "slug":
queryset = queryset.filter(in_iexact("slug", value))
elif key == "email":
queryset = queryset.filter(
in_iexact("members__email", value))
elif key == "platform":
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(
platform__in=value).values("project_id"))
elif key == "id":
queryset = queryset.filter(id__in=value)
elif key == "status":
try:
queryset = queryset.filter(status__in=[
OrganizationStatus[v.upper()] for v in value
])
except KeyError:
queryset = queryset.none()
elif key == "member_id":
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
id__in=value).values("organization"))
else:
queryset = queryset.none()
sort_by = request.GET.get("sortBy")
if sort_by == "members":
queryset = queryset.annotate(member_count=Count("member_set"))
order_by = "-member_count"
paginator_cls = OffsetPaginator
elif sort_by == "projects":
queryset = queryset.annotate(project_count=Count("project"))
order_by = "-project_count"
paginator_cls = OffsetPaginator
elif sort_by == "events":
queryset = queryset.annotate(
event_count=Sum("stats__events_24h")).filter(
stats__events_24h__isnull=False)
order_by = "-event_count"
paginator_cls = OffsetPaginator
else:
order_by = "-date_added"
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool member: restrict results to organizations which you have
membership
:auth: required
"""
member_only = request.GET.get('member') in ('1', 'true')
queryset = Organization.objects.filter(
status=OrganizationStatus.VISIBLE,
)
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(
id=request.auth.project.organization_id
)
elif request.auth.organization is not None:
queryset = queryset.filter(
id=request.auth.organization.id
)
elif member_only or not request.is_superuser():
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
user=request.user,
).values('organization'),
)
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) |
Q(slug__icontains=value) |
Q(members__email__iexact=value)
)
elif key == 'slug':
queryset = queryset.filter(
in_iexact('slug', value)
)
elif key == 'email':
queryset = queryset.filter(
in_iexact('members__email', value)
)
elif key == 'platform':
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(
platform__in=value,
).values('project_id')
)
elif key == 'id':
queryset = queryset.filter(id__in=value)
sort_by = request.GET.get('sortBy')
if sort_by == 'members':
queryset = queryset.annotate(
member_count=Count('member_set'),
)
order_by = '-member_count'
paginator_cls = OffsetPaginator
elif sort_by == 'projects':
queryset = queryset.annotate(
project_count=Count('project'),
)
order_by = '-project_count'
paginator_cls = OffsetPaginator
elif sort_by == 'events':
queryset = queryset.annotate(
event_count=Sum('stats__events_24h'),
).filter(
stats__events_24h__isnull=False,
)
order_by = '-event_count'
paginator_cls = OffsetPaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
"""
List an Organization's Projects
```````````````````````````````
Return a list of projects bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the projects should be listed.
:auth: required
"""
stats_period = request.GET.get('statsPeriod')
if stats_period not in (None, '', '24h', '14d', '30d'):
return Response(
{
'error': {
'params': {
'stats_period': {
'message': ERR_INVALID_STATS_PERIOD
},
},
}
},
status=400)
elif not stats_period:
# disable stats
stats_period = None
if request.auth and not request.user.is_authenticated():
# TODO: remove this, no longer supported probably
if hasattr(request.auth, 'project'):
team_list = list(request.auth.project.teams.all())
queryset = Project.objects.filter(
id=request.auth.project.id, ).prefetch_related('teams')
elif request.auth.organization is not None:
org = request.auth.organization
team_list = list(Team.objects.filter(organization=org, ))
queryset = Project.objects.filter(
teams__in=team_list, ).prefetch_related('teams')
else:
return Response(
{
'detail':
'Current access does not point to '
'organization.'
},
status=400)
else:
team_list = list(request.access.teams)
queryset = Project.objects.filter(
teams__in=team_list, ).prefetch_related('teams')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
else:
queryset = queryset.none()
queryset = queryset.distinct()
return self.paginate(
request=request,
queryset=queryset,
order_by='slug',
on_results=lambda x: serialize(
x, request.user,
ProjectSummarySerializer(
environment_id=self._get_environment_id_from_request(
request,
organization.id,
),
stats_period=stats_period,
)),
paginator_cls=OffsetPaginator,
)
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool member: restrict results to organizations which you have
membership
:qparam bool owner: restrict results to organizations which are owner
:auth: required
"""
member_only = request.GET.get('member') in ('1', 'true')
owner_only = request.GET.get('owner') in ('1', 'true')
queryset = Organization.objects.all()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(
id=request.auth.project.organization_id)
elif request.auth.organization is not None:
queryset = queryset.filter(id=request.auth.organization.id)
elif owner_only:
# This is used when closing an account
queryset = queryset.filter(
member_set__role=roles.get_top_dog().id,
member_set__user=request.user,
status=OrganizationStatus.VISIBLE,
)
org_results = []
for org in sorted(queryset, key=lambda x: x.name):
# O(N) query
org_results.append({
'organization': serialize(org),
'singleOwner': org.has_single_owner(),
})
return Response(org_results)
elif member_only or not is_active_superuser(request):
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
user=request.user, ).values('organization'), )
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value)
| Q(members__email__iexact=value))
elif key == 'slug':
queryset = queryset.filter(in_iexact('slug', value))
elif key == 'email':
queryset = queryset.filter(
in_iexact('members__email', value))
elif key == 'platform':
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(
platform__in=value, ).values('project_id'))
elif key == 'id':
queryset = queryset.filter(id__in=value)
elif key == 'status':
try:
queryset = queryset.filter(status__in=[
OrganizationStatus[v.upper()] for v in value
])
except KeyError:
queryset = queryset.none()
else:
queryset = queryset.none()
sort_by = request.GET.get('sortBy')
if sort_by == 'members':
queryset = queryset.annotate(member_count=Count('member_set'), )
order_by = '-member_count'
paginator_cls = OffsetPaginator
elif sort_by == 'projects':
queryset = queryset.annotate(project_count=Count('project'), )
order_by = '-project_count'
paginator_cls = OffsetPaginator
elif sort_by == 'events':
queryset = queryset.annotate(
event_count=Sum('stats__events_24h'), ).filter(
stats__events_24h__isnull=False, )
order_by = '-event_count'
paginator_cls = OffsetPaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request):
"""
List your Projects
``````````````````
Return a list of projects available to the authenticated
session.
:auth: required
"""
queryset = Project.objects.select_related('organization').distinct()
status = request.GET.get('status', 'active')
if status == 'active':
queryset = queryset.filter(
status=ProjectStatus.VISIBLE,
)
elif status == 'deleted':
queryset = queryset.exclude(
status=ProjectStatus.VISIBLE,
)
elif status:
queryset = queryset.none()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(
id=request.auth.project_id,
)
elif request.auth.organization is not None:
queryset = queryset.filter(
organization=request.auth.organization.id,
)
else:
queryset = queryset.none()
elif not request.is_superuser():
queryset = queryset.filter(
team__organizationmember__user=request.user,
)
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) |
Q(slug__icontains=value)
)
elif key == 'slug':
queryset = queryset.filter(
in_iexact('slug', value)
)
elif key == 'name':
queryset = queryset.filter(
in_iexact('name', value)
)
elif key == 'platform':
queryset = queryset.filter(
id__in=ProjectPlatform.objects.filter(
platform__in=value,
).values('project_id')
)
elif key == 'id':
queryset = queryset.filter(id__in=value)
return self.paginate(
request=request,
queryset=queryset,
order_by='-date_added',
on_results=lambda x: serialize(x, request.user, ProjectWithOrganizationSerializer()),
paginator_cls=DateTimePaginator,
)
def get(self, request, organization=None):
if (request.GET.get("show") == "all" and is_active_superuser(request)
and request.access.has_permission("broadcasts.admin")):
# superusers can slice and dice
queryset = Broadcast.objects.all().order_by("-date_added")
else:
# only allow active broadcasts if they're not a superuser
queryset = Broadcast.objects.filter(
Q(date_expires__isnull=True)
| Q(date_expires__gt=timezone.now()),
is_active=True).order_by("-date_added")
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(title__icontains=value)
| Q(message__icontains=value)
| Q(link__icontains=value))
elif key == "id":
queryset = queryset.filter(id__in=value)
elif key == "link":
queryset = queryset.filter(in_icontains("link", value))
elif key == "status":
filters = []
for v in value:
v = v.lower()
if v == "active":
filters.append(
Q(date_expires__isnull=True, is_active=True)
| Q(date_expires__gt=timezone.now(),
is_active=True))
elif v == "inactive":
filters.append(
Q(date_expires__lt=timezone.now())
| Q(is_active=False))
else:
queryset = queryset.none()
if filters:
queryset = queryset.filter(
six.moves.reduce(or_, filters))
else:
queryset = queryset.none()
if organization:
data = self._secondary_filtering(request, organization, queryset)
return self.respond(self._serialize_objects(data, request))
sort_by = request.GET.get("sortBy")
if sort_by == "expires":
order_by = "-date_expires"
paginator_cls = DateTimePaginator
else:
order_by = "-date_added"
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: self._serialize_objects(x, request),
paginator_cls=paginator_cls,
)
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool member: restrict results to organizations which you have
membership
:qparam bool owner: restrict results to organizations which are owner
:auth: required
"""
owner_only = request.GET.get('owner') in ('1', 'true')
queryset = Organization.objects.distinct()
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(id=request.auth.project.organization_id)
elif request.auth.organization is not None:
queryset = queryset.filter(id=request.auth.organization.id)
elif owner_only:
# This is used when closing an account
queryset = queryset.filter(
member_set__role=roles.get_top_dog().id,
member_set__user=request.user,
status=OrganizationStatus.VISIBLE,
)
org_results = []
for org in sorted(queryset, key=lambda x: x.name):
# O(N) query
org_results.append({
'organization': serialize(org),
'singleOwner': org.has_single_owner(),
})
return Response(org_results)
elif not (is_active_superuser(request) and request.GET.get('show') == 'all'):
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
user=request.user,
).values('organization'),
)
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value) |
Q(members__email__iexact=value)
)
elif key == 'slug':
queryset = queryset.filter(in_iexact('slug', value))
elif key == 'email':
queryset = queryset.filter(in_iexact('members__email', value))
elif key == 'platform':
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(
platform__in=value,
).values('project_id')
)
elif key == 'id':
queryset = queryset.filter(id__in=value)
elif key == 'status':
try:
queryset = queryset.filter(status__in=[
OrganizationStatus[v.upper()] for v in value
])
except KeyError:
queryset = queryset.none()
else:
queryset = queryset.none()
sort_by = request.GET.get('sortBy')
if sort_by == 'members':
queryset = queryset.annotate(
member_count=Count('member_set'),
)
order_by = '-member_count'
paginator_cls = OffsetPaginator
elif sort_by == 'projects':
queryset = queryset.annotate(
project_count=Count('project'),
)
order_by = '-project_count'
paginator_cls = OffsetPaginator
elif sort_by == 'events':
queryset = queryset.annotate(
event_count=Sum('stats__events_24h'),
).filter(
stats__events_24h__isnull=False,
)
order_by = '-event_count'
paginator_cls = OffsetPaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool member: restrict results to organizations which you have
membership
:auth: required
"""
member_only = request.GET.get('member') in ('1', 'true')
queryset = Organization.objects.filter(
status=OrganizationStatus.VISIBLE, )
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, 'project'):
queryset = queryset.filter(
id=request.auth.project.organization_id)
elif request.auth.organization is not None:
queryset = queryset.filter(id=request.auth.organization.id)
elif member_only or not is_active_superuser(request):
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(
user=request.user, ).values('organization'), )
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value)
| Q(members__email__iexact=value))
elif key == 'slug':
queryset = queryset.filter(in_iexact('slug', value))
elif key == 'email':
queryset = queryset.filter(
in_iexact('members__email', value))
elif key == 'platform':
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(
platform__in=value, ).values('project_id'))
elif key == 'id':
queryset = queryset.filter(id__in=value)
sort_by = request.GET.get('sortBy')
if sort_by == 'members':
queryset = queryset.annotate(member_count=Count('member_set'), )
order_by = '-member_count'
paginator_cls = OffsetPaginator
elif sort_by == 'projects':
queryset = queryset.annotate(project_count=Count('project'), )
order_by = '-project_count'
paginator_cls = OffsetPaginator
elif sort_by == 'events':
queryset = queryset.annotate(
event_count=Sum('stats__events_24h'), ).filter(
stats__events_24h__isnull=False, )
order_by = '-event_count'
paginator_cls = OffsetPaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
queryset = (OrganizationMember.objects.filter(
Q(user__is_active=True) | Q(user__isnull=True),
organization=organization,
invite_status=InviteStatus.APPROVED.value,
).select_related("user").order_by("email", "user__email"))
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "email":
queryset = queryset.filter(
Q(email__in=value)
| Q(user__email__in=value)
| Q(user__emails__email__in=value))
elif key == "scope":
queryset = queryset.filter(
role__in=[r.id for r in roles.with_any_scope(value)])
elif key == "role":
queryset = queryset.filter(role__in=value)
elif key == "isInvited":
isInvited = "true" in value
queryset = queryset.filter(user__isnull=isInvited)
elif key == "ssoLinked":
ssoFlag = OrganizationMember.flags["sso:linked"]
ssoLinked = "true" in value
if ssoLinked:
queryset = queryset.filter(
flags=F("flags").bitor(ssoFlag))
else:
queryset = queryset.filter(
flags=F("flags").bitand(~ssoFlag))
elif key == "has2fa":
has2fa = "true" in value
if has2fa:
types = [
a.type for a in available_authenticators(
ignore_backup=True)
]
queryset = queryset.filter(
user__authenticator__isnull=False,
user__authenticator__type__in=types)
else:
queryset = queryset.filter(
user__authenticator__isnull=True)
elif key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(email__icontains=value)
| Q(user__email__icontains=value)
| Q(user__name__icontains=value))
else:
queryset = queryset.none()
return self.paginate(
request=request,
queryset=queryset,
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
List an Organization's Projects
```````````````````````````````
Return a list of projects bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the projects should be listed.
:auth: required
"""
stats_period = request.GET.get('statsPeriod')
if stats_period not in (None, '', '24h', '14d', '30d'):
return Response(
{
'error': {
'params': {
'stats_period': {
'message': ERR_INVALID_STATS_PERIOD
},
},
}
},
status=400
)
elif not stats_period:
# disable stats
stats_period = None
if request.auth and not request.user.is_authenticated():
# TODO: remove this, no longer supported probably
if hasattr(request.auth, 'project'):
team_list = list(request.auth.project.teams.all())
queryset = Project.objects.filter(
id=request.auth.project.id,
).prefetch_related('teams')
elif request.auth.organization is not None:
org = request.auth.organization
team_list = list(Team.objects.filter(
organization=org,
))
queryset = Project.objects.filter(
teams__in=team_list,
).prefetch_related('teams')
else:
return Response(
{
'detail': 'Current access does not point to '
'organization.'
}, status=400
)
else:
queryset = Project.objects.filter(
organization=organization,
).prefetch_related('teams')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(Q(name__icontains=value) | Q(slug__icontains=value))
elif key == 'id':
queryset = queryset.filter(id__in=value)
else:
queryset = queryset.none()
queryset = queryset.filter(status=ProjectStatus.VISIBLE).distinct()
return self.paginate(
request=request,
queryset=queryset,
order_by='slug',
on_results=lambda x: serialize(x, request.user, ProjectSummarySerializer(
environment_id=self._get_environment_id_from_request(
request,
organization.id,
),
stats_period=stats_period,
)),
paginator_cls=OffsetPaginator,
)
def get(self, request: Request, organization) -> Response:
"""
List an Organization's Projects
```````````````````````````````
Return a list of projects bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the projects should be listed.
:auth: required
"""
stats_period = request.GET.get("statsPeriod")
collapse = request.GET.getlist("collapse", [])
if stats_period not in (None, "", "1h", "24h", "7d", "14d", "30d"):
return Response(
{
"error": {
"params": {
"stats_period": {
"message": ERR_INVALID_STATS_PERIOD
}
}
}
},
status=400,
)
elif not stats_period:
# disable stats
stats_period = None
if request.auth and not request.user.is_authenticated:
# TODO: remove this, no longer supported probably
if hasattr(request.auth, "project"):
team_list = list(request.auth.project.teams.all())
queryset = Project.objects.filter(id=request.auth.project.id)
elif request.auth.organization is not None:
org = request.auth.organization
team_list = list(Team.objects.filter(organization=org))
queryset = Project.objects.filter(teams__in=team_list)
else:
return Response(
{
"detail":
"Current access does not point to "
"organization."
},
status=400)
else:
queryset = Project.objects.filter(organization=organization)
order_by = ["slug"]
if request.user.is_authenticated:
queryset = queryset.extra(
select={
"is_bookmarked":
"""exists (
select *
from sentry_projectbookmark spb
where spb.project_id = sentry_project.id and spb.user_id = %s
)"""
},
select_params=(request.user.id, ),
)
order_by.insert(0, "-is_bookmarked")
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in tokens.items():
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
elif key == "id":
queryset = queryset.filter(id__in=value)
elif key == "slug":
queryset = queryset.filter(slug__in=value)
elif key == "team":
team_list = list(Team.objects.filter(slug__in=value))
queryset = queryset.filter(teams__in=team_list)
elif key == "!team":
team_list = list(Team.objects.filter(slug__in=value))
queryset = queryset.exclude(teams__in=team_list)
elif key == "is_member":
queryset = queryset.filter(
teams__organizationmember__user=request.user)
else:
queryset = queryset.none()
queryset = queryset.filter(status=ProjectStatus.VISIBLE).distinct()
# TODO(davidenwang): remove this after frontend requires only paginated projects
get_all_projects = request.GET.get("all_projects") == "1"
if get_all_projects:
queryset = queryset.order_by("slug").select_related("organization")
return Response(
serialize(list(queryset), request.user,
ProjectSummarySerializer(collapse=collapse)))
else:
def serialize_on_result(result):
transaction_stats = request.GET.get("transactionStats")
session_stats = request.GET.get("sessionStats")
environment_id = self._get_environment_id_from_request(
request, organization.id)
serializer = ProjectSummarySerializer(
environment_id=environment_id,
stats_period=stats_period,
transaction_stats=transaction_stats,
session_stats=session_stats,
collapse=collapse,
)
return serialize(result, request.user, serializer)
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=serialize_on_result,
paginator_cls=OffsetPaginator,
)
def get(self, request, organization):
"""
List an Organization's Projects
```````````````````````````````
Return a list of projects bound to a organization.
:pparam string organization_slug: the slug of the organization for
which the projects should be listed.
:auth: required
"""
stats_period = request.GET.get("statsPeriod")
if stats_period not in (None, "", "24h", "14d", "30d"):
return Response(
{
"error": {
"params": {
"stats_period": {
"message": ERR_INVALID_STATS_PERIOD
}
}
}
},
status=400,
)
elif not stats_period:
# disable stats
stats_period = None
if request.auth and not request.user.is_authenticated():
# TODO: remove this, no longer supported probably
if hasattr(request.auth, "project"):
team_list = list(request.auth.project.teams.all())
queryset = Project.objects.filter(
id=request.auth.project.id).prefetch_related("teams")
elif request.auth.organization is not None:
org = request.auth.organization
team_list = list(Team.objects.filter(organization=org))
queryset = Project.objects.filter(
teams__in=team_list).prefetch_related("teams")
else:
return Response(
{
"detail":
"Current access does not point to "
"organization."
},
status=400)
else:
queryset = Project.objects.filter(
organization=organization).prefetch_related("teams")
order_by = ["slug"]
if request.user.is_authenticated():
queryset = queryset.extra(
select={
"is_bookmarked":
"""exists (
select *
from sentry_projectbookmark spb
where spb.project_id = sentry_project.id and spb.user_id = %s
)"""
},
select_params=(request.user.id, ),
)
order_by.insert(0, "-is_bookmarked")
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value))
elif key == "id":
queryset = queryset.filter(id__in=value)
elif key == "slug":
queryset = queryset.filter(slug__in=value)
elif key == "team":
team_list = list(Team.objects.filter(slug__in=value))
queryset = queryset.filter(teams__in=team_list)
elif key == "!team":
team_list = list(Team.objects.filter(slug__in=value))
queryset = queryset.exclude(teams__in=team_list)
else:
queryset = queryset.none()
queryset = queryset.filter(status=ProjectStatus.VISIBLE).distinct()
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(
x,
request.user,
ProjectSummarySerializer(
environment_id=self._get_environment_id_from_request(
request, organization.id),
stats_period=stats_period,
),
),
paginator_cls=OffsetPaginator,
)
def get(self, request):
if request.GET.get('show') == 'all' and is_active_superuser(
request) and request.access.has_permission('broadcasts.admin'):
# superusers can slice and dice
queryset = Broadcast.objects.all()
else:
# only allow active broadcasts if they're not a superuser
queryset = Broadcast.objects.filter(
Q(date_expires__isnull=True)
| Q(date_expires__gt=timezone.now()),
is_active=True,
).order_by('-date_added')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(title__icontains=value) | Q(message__icontains=value)
| Q(link__icontains=value))
elif key == 'id':
queryset = queryset.filter(id__in=value)
elif key == 'link':
queryset = queryset.filter(in_icontains('link', value))
elif key == 'status':
filters = []
for v in value:
v = v.lower()
if v == 'active':
filters.append(
Q(date_expires__isnull=True, is_active=True)
| Q(date_expires__gt=timezone.now(),
is_active=True))
elif v == 'inactive':
filters.append(
Q(date_expires__lt=timezone.now())
| Q(is_active=False))
else:
queryset = queryset.none()
if filters:
queryset = queryset.filter(
six.moves.reduce(or_, filters))
else:
queryset = queryset.none()
sort_by = request.GET.get('sortBy')
if sort_by == 'expires':
order_by = '-date_expires'
paginator_cls = DateTimePaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: self._serialize_objects(x, request),
paginator_cls=paginator_cls,
)
def get(self, request, organization):
"""
Retrieve monitors for an organization
`````````````````````````````````````
:pparam string organization_slug: the slug of the organization
:auth: required
"""
if not features.has('organizations:monitors',
organization, actor=request.user):
raise ResourceDoesNotExist
try:
filter_params = self.get_filter_params(
request,
organization,
date_filter_optional=True,
)
except NoProjects:
return self.respond([])
except OrganizationEventsError as exc:
return self.respond({'detail': exc.message}, status=400)
queryset = Monitor.objects.filter(
organization_id=organization.id,
project_id__in=filter_params['project_id'],
).exclude(
status__in=[MonitorStatus.PENDING_DELETION, MonitorStatus.DELETION_IN_PROGRESS],
)
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(Q(name__icontains=value) | Q(id__iexact=value))
elif key == 'id':
queryset = queryset.filter(in_iexact('id', value))
elif key == 'name':
queryset = queryset.filter(in_iexact('name', value))
elif key == 'status':
try:
queryset = queryset.filter(
status__in=map_value_to_constant(
MonitorStatus, value))
except ValueError:
queryset = queryset.none()
elif key == 'type':
try:
queryset = queryset.filter(
status__in=map_value_to_constant(
MonitorType, value))
except ValueError:
queryset = queryset.none()
elif key == 'id':
queryset = queryset.filter(id__in=value)
else:
queryset = queryset.none()
queryset = queryset.extra(
select={
'is_error': 'sentry_monitor.status = %s' % (MonitorStatus.ERROR,),
},
)
return self.paginate(
request=request,
queryset=queryset,
order_by=('-is_error', '-name'),
on_results=lambda x: serialize(x, request.user),
paginator_cls=OffsetPaginator,
)
def get(self, request):
if request.GET.get('show') == 'all' and is_active_superuser(
request) and request.access.has_permission('broadcasts.admin'):
# superusers can slice and dice
queryset = Broadcast.objects.all()
else:
# only allow active broadcasts if they're not a superuser
queryset = Broadcast.objects.filter(
Q(date_expires__isnull=True) | Q(date_expires__gt=timezone.now()),
is_active=True,
).order_by('-date_added')
query = request.GET.get('query')
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == 'query':
value = ' '.join(value)
queryset = queryset.filter(
Q(title__icontains=value) | Q(
message__icontains=value) | Q(link__icontains=value)
)
elif key == 'id':
queryset = queryset.filter(id__in=value)
elif key == 'link':
queryset = queryset.filter(in_icontains('link', value))
elif key == 'status':
filters = []
for v in value:
v = v.lower()
if v == 'active':
filters.append(
Q(date_expires__isnull=True, is_active=True) | Q(
date_expires__gt=timezone.now(), is_active=True)
)
elif v == 'inactive':
filters.append(
Q(date_expires__lt=timezone.now()) | Q(is_active=False)
)
else:
queryset = queryset.none()
if filters:
queryset = queryset.filter(six.moves.reduce(or_, filters))
else:
queryset = queryset.none()
sort_by = request.GET.get('sortBy')
if sort_by == 'expires':
order_by = '-date_expires'
paginator_cls = DateTimePaginator
else:
order_by = '-date_added'
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: self._serialize_objects(x, request),
paginator_cls=paginator_cls,
)
def test_tokenize_query_only_keyed_fields():
assert tokenize_query("foo:bar") == {"foo": ["bar"]}
def get(self, request):
"""
List your Organizations
```````````````````````
Return a list of organizations available to the authenticated
session. This is particularly useful for requests with an
user bound context. For API key based requests this will
only return the organization that belongs to the key.
:qparam bool member: restrict results to organizations which you have
membership
:auth: required
"""
member_only = request.GET.get("member") in ("1", "true")
queryset = Organization.objects.filter(status=OrganizationStatus.VISIBLE)
if request.auth and not request.user.is_authenticated():
if hasattr(request.auth, "project"):
queryset = queryset.filter(id=request.auth.project.organization_id)
elif request.auth.organization is not None:
queryset = queryset.filter(id=request.auth.organization.id)
elif member_only or not request.is_superuser():
queryset = queryset.filter(
id__in=OrganizationMember.objects.filter(user=request.user).values("organization")
)
query = request.GET.get("query")
if query:
tokens = tokenize_query(query)
for key, value in six.iteritems(tokens):
if key == "query":
value = " ".join(value)
queryset = queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value) | Q(members__email__iexact=value)
)
elif key == "slug":
queryset = queryset.filter(in_iexact("slug", value))
elif key == "email":
queryset = queryset.filter(in_iexact("members__email", value))
elif key == "platform":
queryset = queryset.filter(
project__in=ProjectPlatform.objects.filter(platform__in=value).values("project_id")
)
sort_by = request.GET.get("sortBy")
if sort_by == "members":
queryset = queryset.annotate(member_count=Count("member_set"))
order_by = "-member_count"
paginator_cls = OffsetPaginator
elif sort_by == "projects":
queryset = queryset.annotate(project_count=Count("project"))
order_by = "-project_count"
paginator_cls = OffsetPaginator
elif sort_by == "events":
queryset = queryset.annotate(event_count=Sum("stats__events_24h")).filter(stats__events_24h__isnull=False)
order_by = "-event_count"
paginator_cls = OffsetPaginator
else:
order_by = "-date_added"
paginator_cls = DateTimePaginator
return self.paginate(
request=request,
queryset=queryset,
order_by=order_by,
on_results=lambda x: serialize(x, request.user),
paginator_cls=paginator_cls,
)
