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): """ 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) ) 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 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, organization, member): email_list = list( UserEmail.objects.filter( user=member.user_id, is_verified=True, ).values_list('email', flat=True)) if email_list: queryset = Commit.objects.filter( organization_id=organization.id, author__in=CommitAuthor.objects.filter( in_iexact('email', email_list), organization_id=organization.id, )).order_by('-date_added') else: queryset = Commit.objects.none() return self.paginate( request=request, queryset=queryset, order_by='-date_added', paginator_cls=OffsetPaginator, # TODO(dcramer): we dont want to return author here on_results=lambda x: serialize(x, request.user, CommitWithReleaseSerializer()), )
def get_users_for_commits(item_list): """ Returns a dictionary of author_id => user, if a Sentry user object exists for that email. If there is no matching Sentry user, a {user, email} dict representation of that author is returned. e.g. { 1: serialized(<User id=1>), 2: {email: '*****@*****.**', name: 'dunno'}, ... } """ authors = set(c.author for c in item_list if c.author is not None) if not len(authors): return {} # Filter users based on the emails provided in the commits user_emails = UserEmail.objects.filter( in_iexact('email', [a.email for a in authors]), ).order_by('id') org_ids = set(item.organization_id for item in item_list) assert len(org_ids) == 1 org_id = org_ids.pop() # Filter users belonging to the organization associated with # the release users = User.objects.filter( id__in=[ue.user_id for ue in user_emails], sentry_orgmember_set__organization_id=org_id ) users_by_id = dict((user.id, serialize(user)) for user in users) # Figure out which email address matches to a user users_by_email = {} for email in user_emails: if email.email not in users_by_email: user = users_by_id.get(email.user_id, None) # user can be None if there's a user associated # with user_email in separate organization if user: users_by_email[email.email] = user author_objs = {} for author in authors: author_objs[author.id] = users_by_email.get(author.email, { "name": author.name, "email": author.email }) return author_objs
def get_users_by_emails(self, emails: Iterable[str], organization: Organization) -> Mapping[str, User]: if not emails: return {} return { ue.email: ue.user for ue in self.get_for_organization(organization).filter( in_iexact("email", emails), is_verified=True, ).select_related("user") }
def get_users_by_emails(emails: Iterable[str], organization: Organization) -> Mapping[str, User]: if not emails: return {} return { ue.email: ue.user for ue in UserEmail.objects.filter( in_iexact("email", emails), is_verified=True, user__sentry_orgmember_set__organization=organization, ).select_related("user") }
def get_users_for_authors(organization_id, authors, user=None): """ Returns a dictionary of author_id => user, if a Sentry user object exists for that email. If there is no matching Sentry user, a {user, email} dict representation of that author is returned. e.g. { 1: serialized(<User id=1>), 2: {email: '*****@*****.**', name: 'dunno'}, ... } """ # Filter users based on the emails provided in the commits user_emails = list( UserEmail.objects.filter(in_iexact("email", [a.email for a in authors])).order_by("id")) # Filter users belonging to the organization associated with # the release users = User.objects.filter( id__in={ue.user_id for ue in user_emails}, is_active=True, sentry_orgmember_set__organization_id=organization_id, ) users = serialize(list(users), user) users_by_id = {user["id"]: user for user in users} # Figure out which email address matches to a user users_by_email = {} for email in user_emails: # force emails to lower case so we can do case insensitive matching lower_email = email.email.lower() if lower_email not in users_by_email: user = users_by_id.get(six.text_type(email.user_id), None) # user can be None if there's a user associated # with user_email in separate organization if user: users_by_email[lower_email] = user results = {} for author in authors: results[six.text_type(author.id)] = users_by_email.get( author.email.lower(), { "name": author.name, "email": author.email }) return results
def get_users_for_authors(organization_id, authors, user=None): """ Returns a dictionary of author_id => user, if a Sentry user object exists for that email. If there is no matching Sentry user, a {user, email} dict representation of that author is returned. e.g. { 1: serialized(<User id=1>), 2: {email: '*****@*****.**', name: 'dunno'}, ... } """ # Filter users based on the emails provided in the commits user_emails = list( UserEmail.objects.filter( in_iexact('email', [a.email for a in authors]), ).order_by('id') ) # Filter users belonging to the organization associated with # the release users = User.objects.filter( id__in={ue.user_id for ue in user_emails}, is_active=True, sentry_orgmember_set__organization_id=organization_id ) users = serialize(list(users), user) users_by_id = {user['id']: user for user in users} # Figure out which email address matches to a user users_by_email = {} for email in user_emails: if email.email not in users_by_email: user = users_by_id.get(six.text_type(email.user_id), None) # user can be None if there's a user associated # with user_email in separate organization if user: users_by_email[email.email] = user results = {} for author in authors: results[six.text_type(author.id)] = users_by_email.get( author.email, {'name': author.name, 'email': author.email} ) return results
def get_participants(self): if not self.email_list: return {} # identify members which have been seen in the commit log and have # verified the matching email address return { user: GroupSubscriptionReason.committed for user in User.objects.filter( in_iexact('emails__email', self.email_list), emails__is_verified=True, sentry_orgmember_set__teams=Team.objects.filter( id__in=[p.team_id for p in self.projects]), is_active=True, ).distinct() }
def get_participants(self): project = self.project email_list = set( [c.author.email for c in self.commit_list if c.author]) if not email_list: return {} # identify members which have been seen in the commit log and have # verified the matching email address return { user: GroupSubscriptionReason.committed for user in User.objects.filter( in_iexact('emails__email', email_list), emails__is_verified=True, sentry_orgmember_set__teams=project.team, is_active=True, ).distinct() }
def get_participants(self): project = self.project email_list = set([ c.author.email for c in self.commit_list if c.author ]) if not email_list: return {} # identify members which have been seen in the commit log and have # verified the matching email address return { user: GroupSubscriptionReason.committed for user in User.objects.filter( in_iexact('emails__email', email_list), emails__is_verified=True, sentry_orgmember_set__teams=project.team, is_active=True, ).distinct() if features.has('workflow:release-emails', actor=user) }
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, 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 __init__(self, activity): super(ReleaseActivityEmail, self).__init__(activity) self.organization = self.project.organization self.user_id_team_lookup = None self.email_list = {} self.user_ids = {} try: self.deploy = Deploy.objects.get(id=activity.data["deploy_id"]) except Deploy.DoesNotExist: self.deploy = None try: self.release = Release.objects.get( organization_id=self.project.organization_id, version=activity.data["version"]) except Release.DoesNotExist: self.release = None self.repos = [] self.projects = [] else: self.projects = list(self.release.projects.all()) self.commit_list = [ rc.commit for rc in ReleaseCommit.objects.filter( release=self.release).select_related( "commit", "commit__author") ] repos = { r_id: { "name": r_name, "commits": [] } for r_id, r_name in Repository.objects.filter( organization_id=self.project.organization_id, id__in={c.repository_id for c in self.commit_list}, ).values_list("id", "name") } self.email_list = set( [c.author.email for c in self.commit_list if c.author]) if self.email_list: users = { ue.email: ue.user for ue in UserEmail.objects.filter( in_iexact("email", self.email_list), is_verified=True, user__sentry_orgmember_set__organization=self. organization, ).select_related("user") } self.user_ids = {u.id for u in six.itervalues(users)} else: users = {} for commit in self.commit_list: repos[commit.repository_id]["commits"].append( (commit, users.get(commit.author.email) if commit.author_id else None)) self.repos = repos.values() self.environment = ( Environment.objects.get(id=self.deploy.environment_id).name or "Default Environment") self.group_counts_by_project = dict( Group.objects.filter( project__in=self.projects, id__in=GroupLink.objects.filter( linked_type=GroupLink.LinkedType.commit, linked_id__in=ReleaseCommit.objects.filter( release=self.release).values_list("commit_id", flat=True), ).values_list("group_id", flat=True), ).values_list("project").annotate(num_groups=Count("id")))
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 __init__(self, activity): super(ReleaseActivityEmail, self).__init__(activity) self.organization = self.project.organization self.user_id_team_lookup = None try: self.deploy = Deploy.objects.get(id=activity.data['deploy_id']) except Deploy.DoesNotExist: self.deploy = None try: self.release = Release.objects.get( organization_id=self.project.organization_id, version=activity.data['version'], ) except Release.DoesNotExist: self.release = None self.repos = [] self.projects = [] else: self.projects = list(self.release.projects.all()) self.commit_list = [ rc.commit for rc in ReleaseCommit.objects.filter(release=self.release, ). select_related('commit', 'commit__author') ] repos = { r['id']: { 'name': r['name'], 'commits': [], } for r in Repository.objects.filter( organization_id=self.project.organization_id, id__in={c.repository_id for c in self.commit_list}).values('id', 'name') } self.email_list = set( [c.author.email for c in self.commit_list if c.author]) if self.email_list: users = { ue.email: ue.user for ue in UserEmail.objects.filter( in_iexact('email', self.email_list), is_verified=True, user__sentry_orgmember_set__organization=self. organization, ).select_related('user') } else: users = {} for commit in self.commit_list: repos[commit.repository_id]['commits'].append( (commit, users.get(commit.author.email))) self.repos = repos.values() self.environment = Environment.objects.get( id=self.deploy.environment_id).name or 'Default Environment' self.group_counts_by_project = { row['project']: row['num_groups'] for row in Group.objects.filter( project__in=self.projects, id__in=GroupCommitResolution.objects.filter( commit_id__in=ReleaseCommit.objects.filter( release=self.release, ).values_list('commit_id', flat=True), ).values_list('group_id', flat=True), ).values('project').annotate(num_groups=Count('id')) }
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_users_for_authors(organization_id, authors, user=None): """ Returns a dictionary of author_id => user, if a Sentry user object exists for that email. If there is no matching Sentry user, a {user, email} dict representation of that author is returned. e.g. { 1: serialized(<User id=1>), 2: {email: '*****@*****.**', name: 'dunno'}, ... } """ results = {} fetched = cache.get_many([ _user_to_author_cache_key(organization_id, author) for author in authors ]) if fetched: missed = [] for author in authors: fetched_user = fetched.get( _user_to_author_cache_key(organization_id, author)) if fetched_user is None: missed.append(author) else: results[str(author.id)] = fetched_user else: missed = authors if missed: # Filter users based on the emails provided in the commits user_emails = list( UserEmail.objects.filter( in_iexact("email", [a.email for a in missed])).order_by("id")) # Filter users belonging to the organization associated with # the release users = User.objects.filter( id__in={ue.user_id for ue in user_emails}, is_active=True, sentry_orgmember_set__organization_id=organization_id, ) users = serialize(list(users), user) users_by_id = {user["id"]: user for user in users} # Figure out which email address matches to a user users_by_email = {} for email in user_emails: # force emails to lower case so we can do case insensitive matching lower_email = email.email.lower() if lower_email not in users_by_email: user = users_by_id.get(str(email.user_id), None) # user can be None if there's a user associated # with user_email in separate organization if user: users_by_email[lower_email] = user to_cache = {} for author in missed: results[str(author.id)] = users_by_email.get( author.email.lower(), { "name": author.name, "email": author.email }) to_cache[_user_to_author_cache_key( organization_id, author)] = results[str(author.id)] cache.set_many(to_cache) metrics.incr("sentry.release.get_users_for_authors.missed", amount=len(missed)) metrics.incr("sentry.tasks.process_suspect_commits.total", amount=len(results)) return results
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 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 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): """ 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 __init__(self, activity): super(ReleaseActivityEmail, self).__init__(activity) self.organization = self.project.organization self.user_id_team_lookup = None try: self.deploy = Deploy.objects.get(id=activity.data['deploy_id']) except Deploy.DoesNotExist: self.deploy = None try: self.release = Release.objects.get( organization_id=self.project.organization_id, version=activity.data['version'], ) except Release.DoesNotExist: self.release = None self.repos = [] self.projects = [] else: self.projects = list(self.release.projects.all()) self.commit_list = [ rc.commit for rc in ReleaseCommit.objects.filter( release=self.release, ).select_related('commit', 'commit__author') ] repos = { r['id']: { 'name': r['name'], 'commits': [], } for r in Repository.objects.filter( organization_id=self.project.organization_id, id__in={c.repository_id for c in self.commit_list} ).values('id', 'name') } self.email_list = set([c.author.email for c in self.commit_list if c.author]) if self.email_list: users = { ue.email: ue.user for ue in UserEmail.objects.filter( in_iexact('email', self.email_list), is_verified=True, user__sentry_orgmember_set__organization=self.organization, ).select_related('user') } self.user_ids = {u.id for u in six.itervalues(users)} else: users = {} for commit in self.commit_list: repos[commit.repository_id]['commits'].append( (commit, users.get(commit.author.email) if commit.author_id else None) ) self.repos = repos.values() self.environment = Environment.objects.get( id=self.deploy.environment_id ).name or 'Default Environment' self.group_counts_by_project = { row['project']: row['num_groups'] for row in Group.objects.filter( project__in=self.projects, id__in=GroupCommitResolution.objects.filter( commit_id__in=ReleaseCommit.objects.filter( release=self.release, ).values_list('commit_id', flat=True), ).values_list('group_id', flat=True), ).values('project').annotate(num_groups=Count('id')) }
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, )