def get(self, request, group_id):
"""
List an aggregate's available samples
Return a list of sampled events bound to an aggregate.
{method} {path}
"""
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
events = Event.objects.filter(
group=group
)
return self.paginate(
request=request,
queryset=events,
# TODO(dcramer): we want to sort by datetime
order_by='-id',
on_results=lambda x: serialize(x, request.user),
)
def get(self, request, project_id):
"""
Retrieve event counts for a project
**Draft:** This endpoint may change in the future without notice.
Return a set of points representing a normalized timestamp and the
number of events seen in the period.
{method} {path}?since=1421092384.822244&until=1434052399.443363
Query ranges are limited to Sentry's configured time-series resolutions.
Parameters:
- since: a timestamp to set the start of the query
- until: a timestamp to set the end of the query
- resolution: an explicit resolution to search for (i.e. 10s)
**Note:** resolution should not be used unless you're familiar with Sentry
internals as it's restricted to pre-defined values.
"""
project = Project.objects.get_from_cache(id=project_id, )
assert_perm(project, request.user, request.auth)
data = tsdb.get_range(model=tsdb.models.project,
keys=[project.id],
**self._parse_args(request))[project.id]
return Response(data)
def delete(self, request, project_id, key):
"""
Remove all occurances of the given tag key.
{method} {path}
"""
project = Project.objects.get(
id=project_id,
)
tagkey = TagKey.objects.get(
project=project,
key=key,
)
assert_perm(tagkey, request.user, request.auth)
updated = TagKey.objects.filter(
id=tagkey.id,
status=TagKeyStatus.VISIBLE,
).update(status=TagKeyStatus.PENDING_DELETION)
if updated:
delete_tag_key.delay(object_id=tagkey.id)
AuditLogEntry.objects.create(
organization=project.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=tagkey.id,
event=AuditLogEntryEvent.TAGKEY_REMOVE,
data=tagkey.get_audit_log_data(),
)
return Response(status=204)
def get(self, request, organization_slug):
organization = Organization.objects.get_from_cache(
slug=organization_slug,
)
assert_perm(organization, request.user, request.auth)
team_list = Team.objects.get_for_user(
organization=organization,
user=request.user,
)
project_list = []
for team in team_list:
project_list.extend(Project.objects.get_for_user(
team=team,
user=request.user,
))
project_list.sort(key=lambda x: x.name)
team_map = dict(
(t.id, c) for (t, c) in zip(team_list, serialize(team_list, request.user)),
)
context = []
for project, pdata in zip(project_list, serialize(project_list, request.user)):
pdata['team'] = team_map[project.team_id]
context.append(pdata)
return Response(context)
def get(self, request, project_id):
"""
List a project's releases
Retrieve a list of releases for a given project.
{method} {path}
"""
project = Project.objects.get(
id=project_id,
)
assert_perm(project, request.user, request.auth)
queryset = Release.objects.filter(
project=project,
).order_by('-date_added')
return self.paginate(
request=request,
queryset=queryset,
# TODO(dcramer): we want to sort by date_added
order_by='-id',
on_results=lambda x: serialize(x, request.user),
)
def delete(self, request, project_id, key):
"""
Remove all occurances of the given tag key.
{method} {path}
"""
project = Project.objects.get(id=project_id, )
tagkey = TagKey.objects.get(
project=project,
key=key,
)
assert_perm(tagkey, request.user, request.auth)
if tagkey.status == TagKeyStatus.VISIBLE:
tagkey.update(status=TagKeyStatus.PENDING_DELETION)
delete_tag_key.delay(object_id=tagkey.id)
AuditLogEntry.objects.create(
organization=project.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=tagkey.id,
event=AuditLogEntryEvent.TAGKEY_REMOVE,
data=tagkey.get_audit_log_data(),
)
return Response(status=204)
def get(self, request, team_id):
team = Team.objects.get(id=team_id)
assert_perm(team, request.user, request.auth)
projects = Project.objects.get_for_user(
team=team,
user=request.user,
)
if not projects:
return Response([])
data = tsdb.get_range(
model=tsdb.models.project,
keys=[p.id for p in projects],
**self._parse_args(request)
).values()
summarized = []
for n in range(len(data[0])):
total = sum(d[n][1] for d in data)
summarized.append((data[0][n][0], total))
return Response(summarized)
def post(self, request, group_id):
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
form = NewNoteForm(request.DATA)
if not form.is_valid():
return Response('{"error": "form"}', status=status.HTTP_400_BAD_REQUEST)
if Activity.objects.filter(
group=group,
type=Activity.NOTE,
user=request.user,
data=form.cleaned_data,
datetime__gte=timezone.now() - timedelta(hours=1)
).exists():
return Response('{"error": "duplicate"}', status=status.HTTP_400_BAD_REQUEST)
activity = Activity.objects.create(
group=group,
project=group.project,
type=Activity.NOTE,
user=extract_lazy_object(request.user),
data=form.cleaned_data,
)
# TODO: move this into the queue
activity.send_notification()
return Response(serialize(activity, request.user), status=201)
def put(self, request, project_id):
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth, access=MEMBER_ADMIN)
serializer = ProjectSerializer(project, data=request.DATA, partial=True)
if serializer.is_valid():
project = serializer.save()
options = request.DATA.get('options', {})
if 'sentry:origins' in options:
project.update_option('sentry:origins', options['sentry:origins'].split('\n'))
if 'sentry:resolve_age' in options:
project.update_option('sentry:resolve_age', int(options['sentry:resolve_age']))
AuditLogEntry.objects.create(
organization=project.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=project.id,
event=AuditLogEntryEvent.PROJECT_EDIT,
data=project.get_audit_log_data(),
)
data = serialize(project, request.user)
data['options'] = {
'sentry:origins': '\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age': int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, team_id):
team = Team.objects.get(id=team_id)
assert_perm(team, request.user, request.auth, access=OrganizationMemberType.ADMIN)
# TODO(dcramer): this permission logic is duplicated from the
# transformer
if request.user.is_superuser or team.owner_id == request.user.id:
serializer = TeamAdminSerializer(team, data=request.DATA, partial=True)
else:
serializer = TeamSerializer(team, data=request.DATA, partial=True)
if serializer.is_valid():
team = serializer.save()
AuditLogEntry.objects.create(
organization=team.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_EDIT,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, project_id):
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth, access=MEMBER_ADMIN)
serializer = ProjectSerializer(project,
data=request.DATA,
partial=True)
if serializer.is_valid():
project = serializer.save()
options = request.DATA.get('options', {})
if 'sentry:origins' in options:
project.update_option('sentry:origins',
options['sentry:origins'].split('\n'))
if 'sentry:resolve_age' in options:
project.update_option('sentry:resolve_age',
int(options['sentry:resolve_age']))
data = serialize(project, request.user)
data['options'] = {
'sentry:origins':
'\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age':
int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, group_id):
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
now = timezone.now()
group.resolved_at = now
happened = Group.objects.filter(
id=group.id,
).exclude(status=STATUS_RESOLVED).update(
status=STATUS_RESOLVED,
resolved_at=now,
)
if happened:
create_or_update(
Activity,
project=group.project,
group=group,
type=Activity.SET_RESOLVED,
user=request.user,
)
return Response()
def get(self, request, team_id):
"""
Return a list of the trending groups for a given team.
The resulting query will find groups which have been seen since the
cutoff date, and then sort those by score, returning the highest scoring
groups first.
"""
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth)
minutes = int(request.REQUEST.get("minutes", 15))
limit = min(100, int(request.REQUEST.get("limit", 10)))
project_list = Project.objects.get_for_user(user=request.user, team=team)
project_dict = dict((p.id, p) for p in project_list)
cutoff = timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(
Group.objects.filter(
project__in=project_dict.keys(), status=GroupStatus.UNRESOLVED, last_seen__gte=cutoff_dt
)
.extra(select={"sort_value": "score"})
.order_by("-score")[:limit]
)
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
return Response(serialize(group_list, request.user))
def post(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
form = NewNoteForm(request.DATA)
if not form.is_valid():
return Response('{"error": "form"}',
status=status.HTTP_400_BAD_REQUEST)
if Activity.objects.filter(group=group,
type=Activity.NOTE,
user=request.user,
data=form.cleaned_data,
datetime__gte=timezone.now() -
timedelta(hours=1)).exists():
return Response('{"error": "duplicate"}',
status=status.HTTP_400_BAD_REQUEST)
activity = Activity.objects.create(
group=group,
project=group.project,
type=Activity.NOTE,
user=extract_lazy_object(request.user),
data=form.cleaned_data,
)
# TODO: move this into the queue
activity.send_notification()
return Response(serialize(activity, request.user), status=201)
def get(self, request, event_id):
event = Event.objects.get(id=event_id)
assert_perm(event, request.user, request.auth)
Event.objects.bind_nodes([event], 'data')
base_qs = Event.objects.filter(
group=event.group_id, ).exclude(id=event.id)
try:
next_event = base_qs.filter(
datetime__gte=event.datetime).order_by('datetime')[0:1].get()
except Event.DoesNotExist:
next_event = None
try:
prev_event = base_qs.filter(
datetime__lte=event.datetime).order_by('-datetime')[0:1].get()
except Event.DoesNotExist:
prev_event = None
data = serialize(event, request.user)
if next_event:
data['nextEventID'] = str(next_event.id)
else:
data['nextEventID'] = None
if prev_event:
data['previousEventID'] = str(prev_event.id)
else:
data['previousEventID'] = None
data['entries'] = self._get_entries(request, event)
return Response(data)
def delete(self, request, team_id):
team = Team.objects.get(id=team_id)
assert_perm(team, request.user, request.auth, access=OrganizationMemberType.ADMIN)
if team.project_set.filter(id=settings.SENTRY_PROJECT).exists():
return Response('{"error": "Cannot remove team containing default project."}',
status=status.HTTP_403_FORBIDDEN)
team.update(status=TeamStatus.PENDING_DELETION)
# we delay the task for 5 minutes so we can implement an undo
kwargs = {'object_id': team.id}
delete_team.apply_async(kwargs=kwargs, countdown=60 * 5)
AuditLogEntry.objects.create(
organization=team.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_REMOVE,
data=team.get_audit_log_data(),
)
return Response(status=204)
def get(self, request, group_id):
"""
Retrieve an aggregate
Return details on an individual aggregate.
{method} {path}
"""
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=7)
seen_by = self._get_seen_by(request, group)
data.update({
'activity': serialize(activity, request.user),
'seenBy': serialize(seen_by, request.user),
})
return Response(data)
def get(self, request, project_id):
"""
Retrieve event counts for a project
**Draft:** This endpoint may change in the future without notice.
Return a set of points representing a normalized timestamp and the
number of events seen in the period.
{method} {path}?since=1421092384.822244&until=1434052399.443363
Query ranges are limited to Sentry's configured time-series resolutions.
Parameters:
- since: a timestamp to set the start of the query
- until: a timestamp to set the end of the query
- resolution: an explicit resolution to search for (i.e. 10s)
**Note:** resolution should not be used unless you're familiar with Sentry
internals as it's restricted to pre-defined values.
"""
project = Project.objects.get_from_cache(id=project_id)
assert_perm(project, request.user, request.auth)
data = tsdb.get_range(model=tsdb.models.project, keys=[project.id], **self._parse_args(request))[project.id]
return Response(data)
def delete(self, request, project_id):
"""
Permanently remove the given groups.
Only queries by 'id' are accepted.
{method} {path}?id=1&id=2&id=3
If any ids are out of scope this operation will succeed without any data
mutation
"""
project = Project.objects.get_from_cache(
id=project_id,
)
assert_perm(project, request.user, request.auth)
group_ids = request.GET.getlist('id')
if group_ids:
group_list = Group.objects.filter(project=project, id__in=group_ids)
# filter down group ids to only valid matches
group_ids = [g.id for g in group_list]
else:
# missing any kind of filter
return Response(status=400)
if not group_ids:
return Response(status=204)
# TODO(dcramer): set status to pending deletion
for group in group_list:
delete_group.delay(object_id=group.id)
return Response(status=204)
def get(self, request, group_id):
"""
Retrieve an aggregate
Return details on an individual aggregate.
{method} {path}
"""
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
data = serialize(group, request.user)
# TODO: these probably should be another endpoint
activity = self._get_activity(request, group, num=7)
seen_by = self._get_seen_by(request, group)
data.update({
'activity': serialize(activity, request.user),
'seenBy': serialize(seen_by, request.user),
})
return Response(data)
def post(self, request, group_id):
group = Group.objects.get(id=group_id)
assert_perm(group, request.user, request.auth)
serializer = GroupAssigneeSerializer(data=request.DATA)
if serializer.is_valid():
user = serializer.object.user
now = timezone.now()
assignee, created = GroupAssignee.objects.get_or_create(
group=group, defaults={"project": group.project, "user": user, "date_added": now}
)
if not created:
affected = (
GroupAssignee.objects.filter(group=group).exclude(user=user).update(user=user, date_added=now)
)
else:
affected = True
if affected:
create_or_update(
Activity, project=group.project, group=group, type=Activity.ASSIGNED, user=request.user
)
return Response()
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, team_id):
team = Team.objects.get(id=team_id)
assert_perm(team,
request.user,
request.auth,
access=OrganizationMemberType.ADMIN)
if team.project_set.filter(id=settings.SENTRY_PROJECT).exists():
return Response(
'{"error": "Cannot remove team containing default project."}',
status=status.HTTP_403_FORBIDDEN)
team.update(status=TeamStatus.PENDING_DELETION)
# we delay the task for 5 minutes so we can implement an undo
kwargs = {'object_id': team.id}
delete_team.apply_async(kwargs=kwargs, countdown=60 * 5)
AuditLogEntry.objects.create(
organization=team.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_REMOVE,
data=team.get_audit_log_data(),
)
return Response(status=204)
def get(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth)
results = list(Project.objects.get_for_user(request.user, team=team))
return Response(serialize(results, request.user))
def get(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth)
data = sorted(AccessGroup.objects.filter(team=team), key=lambda x: x.name)
return Response(serialize(data, request.user))
def post(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
group.delete()
return Response()
def get(self, request, group_id):
group = Group.objects.get(id=group_id)
assert_perm(group, request.user, request.auth)
event = group.get_latest_event()
return HttpResponseRedirect(reverse("sentry-api-0-event-details", kwargs={"event_id": event.id}))
def get(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth)
data = sorted(AccessGroup.objects.filter(team=team), key=lambda x: x.name)
return Response(serialize(data, request.user))
def get(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
data = tsdb.get_range(model=tsdb.models.group,
keys=[group.id],
**self._parse_args(request))[group.id]
return Response(data)
def post(self, request, group_id):
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
group.delete()
return Response()
def get(self, request, group_id):
group = Group.objects.get(id=group_id)
assert_perm(group, request.user)
event = group.get_latest_event()
return HttpResponseRedirect(reverse('sentry-api-0-event-details', kwargs={
'event_id': event.id,
}))
def get(self, request, project_id):
project = Project.objects.get(id=project_id, )
assert_perm(project, request.user, request.auth)
data = tsdb.get_range(model=tsdb.models.project,
keys=[project.id],
**self._parse_args(request))[project.id]
return Response(data)
def get(self, request, user_id):
if user_id == 'me':
user_id = request.user.id
user = User.objects.get(id=user_id)
assert_perm(user, request.user, request.auth)
data = serialize(user, request.user)
return Response(data)
def delete(self, request, organization_slug, member_id):
try:
organization = Organization.objects.get_from_cache(
slug=organization_slug,
)
except Organization.DoesNotExist:
return Response(status=404)
assert_perm(organization, request.user, request.auth)
if request.user.is_superuser:
authorizing_access = OrganizationMemberType.OWNER
else:
authorizing_access = OrganizationMember.objects.get(
organization=organization,
user=request.user,
).type
try:
om = OrganizationMember.objects.filter(
organization=organization,
id=member_id,
type__gte=authorizing_access,
).select_related('user').get()
except OrganizationMember.DoesNotExist:
return Response(status=404)
if self._is_only_owner(om):
return Response(status=403)
audit_data = om.get_audit_log_data()
if om.user_id == organization.owner_id:
# TODO(dcramer): while we still maintain an owner field on
# organization we need to ensure it transfers
organization.owner = OrganizationMember.objects.filter(
type=OrganizationMemberType.OWNER,
).exclude(id=om.id)[0].user
organization.save()
om.delete()
AuditLogEntry.objects.create(
organization=organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=om.id,
target_user=om.user,
event=AuditLogEntryEvent.MEMBER_REMOVE,
data=audit_data,
)
return Response(status=204)
def get(self, request, project_id):
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth)
data = serialize(project, request.user)
data['options'] = {
'sentry:origins': '\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age': int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
def get(self, request, organization_slug):
organization = Organization.objects.get_from_cache(
slug=organization_slug,
)
assert_perm(organization, request.user, request.auth)
group = request.GET.get('group')
if not group:
keys = [organization.id]
elif group == 'project':
team_list = Team.objects.get_for_user(
organization=organization,
user=request.user,
)
project_list = []
for team in team_list:
project_list.extend(Project.objects.get_for_user(
team=team,
user=request.user,
))
keys = [p.id for p in project_list]
else:
raise ValueError('Invalid group: %s' % group)
if not keys:
return Response([])
stat = request.GET.get('stat', 'received')
if stat == 'received':
if group == 'project':
stat_model = tsdb.models.project_total_received
else:
stat_model = tsdb.models.organization_total_received
elif stat == 'rejected':
if group == 'project':
stat_model = tsdb.models.project_total_rejected
else:
stat_model = tsdb.models.organization_total_rejected
else:
raise ValueError('Invalid stat: %s' % stat)
data = tsdb.get_range(
model=stat_model,
keys=keys,
**self._parse_args(request)
)
if not group:
data = data[organization.id]
return Response(data)
def put(self, request, project_id):
"""
Update a project
Update various attributes and configurable settings for the given project.
{method} {path}
{{
"name": "My Project Name",
"options": {{
"sentry:origins": "*"
}}
}}
"""
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth, access=MEMBER_ADMIN)
serializer = ProjectSerializer(project,
data=request.DATA,
partial=True)
if serializer.is_valid():
project = serializer.save()
options = request.DATA.get('options', {})
if 'sentry:origins' in options:
project.update_option('sentry:origins',
options['sentry:origins'].split('\n'))
if 'sentry:resolve_age' in options:
project.update_option('sentry:resolve_age',
int(options['sentry:resolve_age']))
AuditLogEntry.objects.create(
organization=project.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=project.id,
event=AuditLogEntryEvent.PROJECT_EDIT,
data=project.get_audit_log_data(),
)
data = serialize(project, request.user)
data['options'] = {
'sentry:origins':
'\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age':
int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, group_id):
group = Group.objects.get(id=group_id)
assert_perm(group, request.user, request.auth)
event = group.get_latest_event()
return HttpResponseRedirect(
reverse('sentry-api-0-event-details',
kwargs={
'event_id': event.id,
}))
def get(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
events = Event.objects.filter(group=group)
return self.paginate(
request=request,
queryset=events,
order_by='-datetime',
on_results=lambda x: serialize(x, request.user),
)
def get(self, request, organization_slug):
organization = Organization.objects.get_from_cache(
slug=organization_slug, )
assert_perm(organization, request.user, request.auth)
group = request.GET.get('group')
if not group:
keys = [organization.id]
elif group == 'project':
team_list = Team.objects.get_for_user(
organization=organization,
user=request.user,
)
project_list = []
for team in team_list:
project_list.extend(
Project.objects.get_for_user(
team=team,
user=request.user,
))
keys = [p.id for p in project_list]
else:
raise ValueError('Invalid group: %s' % group)
if not keys:
return Response([])
stat = request.GET.get('stat', 'received')
if stat == 'received':
if group == 'project':
stat_model = tsdb.models.project_total_received
else:
stat_model = tsdb.models.organization_total_received
elif stat == 'rejected':
if group == 'project':
stat_model = tsdb.models.project_total_rejected
else:
stat_model = tsdb.models.organization_total_rejected
else:
raise ValueError('Invalid stat: %s' % stat)
data = tsdb.get_range(model=stat_model,
keys=keys,
**self._parse_args(request))
if not group:
data = data[organization.id]
return Response(data)
def put(self, request, project_id):
"""
Update a project
Update various attributes and configurable settings for the given project.
{method} {path}
{{
"name": "My Project Name",
"options": {{
"sentry:origins": "*"
}}
}}
"""
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth, access=MEMBER_ADMIN)
serializer = ProjectSerializer(project, data=request.DATA, partial=True)
if serializer.is_valid():
project = serializer.save()
options = request.DATA.get('options', {})
if 'sentry:origins' in options:
project.update_option('sentry:origins', options['sentry:origins'].split('\n'))
if 'sentry:resolve_age' in options:
project.update_option('sentry:resolve_age', int(options['sentry:resolve_age']))
if 'sentry:scrub_data' in options:
project.update_option('sentry:scrub_data', bool(options['sentry:scrub_data']))
if 'sentry:sensitive_fields' in options:
project.update_option('sentry:sensitive_fields', options['sentry:sensitive_fields'])
AuditLogEntry.objects.create(
organization=project.organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=project.id,
event=AuditLogEntryEvent.PROJECT_EDIT,
data=project.get_audit_log_data(),
)
data = serialize(project, request.user)
data['options'] = {
'sentry:origins': '\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age': int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, project_id):
project = Project.objects.get(id=project_id)
assert_perm(project, request.user, request.auth)
data = serialize(project, request.user)
data['options'] = {
'sentry:origins':
'\n'.join(project.get_option('sentry:origins', None) or []),
'sentry:resolve_age':
int(project.get_option('sentry:resolve_age', 0)),
}
return Response(data)
def get(self, request, project_id):
project = Project.objects.get(id=project_id, )
assert_perm(project, request.user, request.auth)
queryset = Release.objects.filter(
project=project, ).order_by('-date_added')
return self.paginate(
request=request,
queryset=queryset,
order_by='-date_added',
on_results=lambda x: serialize(x, request.user),
)
def get(self, request, project_id):
project = Project.objects.get(
id=project_id,
)
assert_perm(project, request.user)
data = tsdb.get_range(
model=tsdb.models.project,
keys=[project.id],
**self._parse_args(request)
)[project.id]
return Response(data)
def get(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth)
member_list = serialize(
list(team.member_set.select_related('user')),
request.user)
member_list.extend(serialize(
list(team.pending_member_set.all()),
request.user))
member_list.sort(key=lambda x: x['email'])
return Response(member_list)
def get(self, request, team_id):
"""
Retrieve a team.
Return details on an individual team.
{method} {path}
"""
team = Team.objects.get(id=team_id)
assert_perm(team, request.user, request.auth)
return Response(serialize(team, request.user))
def post(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth, access=MEMBER_ADMIN)
serializer = AccessGroupSerializer(data=request.DATA)
if serializer.is_valid():
access_group = serializer.object
access_group.team = team
access_group.managed = False
access_group.save()
return Response(serialize(access_group, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, group_id):
group = Group.objects.get(
id=group_id,
)
assert_perm(group, request.user, request.auth)
data = tsdb.get_range(
model=tsdb.models.group,
keys=[group.id],
**self._parse_args(request)
)[group.id]
return Response(data)
def get(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user)
member_list = serialize(
list(team.member_set.select_related('user')),
request.user)
member_list.extend(serialize(
list(team.pending_member_set.all()),
request.user))
member_list.sort(key=lambda x: x['email'])
return Response(member_list)
def post(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
bookmark = GroupBookmark(
project=group.project,
group=group,
user=request.user,
)
bookmark.save()
return Response()
def get(self, request, release_id):
"""
Retrieve an release
Return details on an individual release.
{method} {path}
"""
release = Release.objects.get(id=release_id)
assert_perm(release, request.user, request.auth)
return Response(serialize(release, request.user))
def post(self, request, team_id):
team = Team.objects.get_from_cache(id=team_id)
assert_perm(team, request.user, request.auth, access=MEMBER_ADMIN)
serializer = AccessGroupSerializer(data=request.DATA)
if serializer.is_valid():
access_group = serializer.object
access_group.team = team
access_group.managed = False
access_group.save()
return Response(serialize(access_group, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, user_id):
if user_id == 'me':
user_id = request.user.id
user = User.objects.get(id=user_id)
assert_perm(user, request.user, request.auth)
serializer = UserSerializer(user, data=request.DATA, partial=True)
if serializer.is_valid():
user = serializer.save()
return Response(serialize(user, request.user))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
notes = Activity.objects.filter(
group=group,
type=Activity.NOTE,
).select_related('user')
return self.paginate(
request=request,
queryset=notes,
order_by='-datetime',
on_results=lambda x: serialize(x, request.user),
)
def post(self, request, group_id):
group = Group.objects.get(id=group_id, )
assert_perm(group, request.user, request.auth)
instance, created = create_or_update(GroupSeen,
group=group,
user=extract_lazy_object(
request.user),
project=group.project,
defaults={
'last_seen': timezone.now(),
})
if created:
return Response(status=201)
return Response(status=204)
