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, )