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