def test_does_not_include_private_projects(self, get_for_user):
get_for_user.return_value = {self.project2.team.id: self.project2.team}
project_list = get_project_list(self.user)
get_for_user.assert_called_once_with(self.user, None)
assert project_list == {
self.project2.id: self.project2,
}
get_for_user.reset_mock()
project_list = get_project_list(self.user, MEMBER_USER)
get_for_user.assert_called_once_with(self.user, MEMBER_USER)
assert project_list == {
self.project2.id: self.project2,
}
def dashboard(request):
project_list = get_project_list(request.user, key='slug')
if len(project_list) == 1:
return HttpResponseRedirect(reverse('sentry', kwargs={'project_id': project_list.keys()[0]}))
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
return render_to_response('sentry/dashboard.html', request=request)
def resolve(request, project):
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(
request.user):
return HttpResponseForbidden()
Group.objects.filter(pk=group.pk).update(status=1)
group.status = 1
data = [(m.pk, {
'html':
render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}).strip(),
'count':
m.times_seen,
}) for m in [group]]
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def remove_project(request, project):
if not can_remove_project(request.user, project):
return HttpResponseRedirect(reverse('sentry'))
project_list = filter(lambda x: x != project, get_project_list(request.user).itervalues())
form = RemoveProjectForm(request.user, project_list, request.POST or None)
if form.is_valid():
removal_type = form.cleaned_data['removal_type']
if removal_type == '1':
project.delete()
elif removal_type == '2':
new_project = form.cleaned_data['project']
project.merge_to(new_project)
elif removal_type == '3':
project.update(status=1)
else:
raise ValueError(removal_type)
return HttpResponseRedirect(reverse('sentry-project-list'))
context = csrf(request)
context.update({
'form': form,
'project': project,
})
return render_to_response('sentry/projects/remove.html', context, request)
def test_does_include_private_projects_without_access(self, get_for_user):
get_for_user.return_value = {self.project2.team.id: self.project2.team}
project_list = get_project_list(self.user)
get_for_user.assert_called_once_with(self.user, None)
self.assertEquals(len(project_list), 2)
self.assertIn(self.project.id, project_list)
self.assertIn(self.project2.id, project_list)
def get_resolved_groups(request, team=None, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if team:
project_list = list(Project.objects.filter(team=team))
elif project:
project_list = [project]
else:
project_list = get_project_list(request.user).values()
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = Group.objects.filter(
project__in=project_list,
status=STATUS_RESOLVED,
resolved_at__gte=cutoff_dt,
).select_related('project').order_by('-score')[:limit]
data = to_json(group_list, request)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def bookmark(request, project):
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
if not request.user.is_authenticated():
return HttpResponseForbidden()
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(
request.user):
return HttpResponseForbidden()
gb, created = GroupBookmark.objects.get_or_create(
project=group.project,
user=request.user,
group=group,
)
if not created:
gb.delete()
response = HttpResponse(json.dumps({'bookmarked': created}))
response['Content-Type'] = 'application/json'
return response
def dashboard(request):
project_list = get_project_list(request.user, key='slug')
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
if project_list:
cutoff = datetime.datetime.now() - datetime.timedelta(days=1)
base_qs = Group.objects.filter(
project__in=project_list.values(),
status=0,
).select_related('project').order_by('-score')
# TODO: change this to calculate the most frequent events in the time period,
# not just events seen within the time period that have at one time been frequent
top_event_list = list(base_qs.filter(
last_seen__gte=cutoff
)[:10])
new_event_list = list(base_qs.filter(
active_at__gte=cutoff,
)[:10])
else:
top_event_list = None
new_event_list = None
return render_to_response('sentry/dashboard.html', {
'top_event_list': top_event_list,
'new_event_list': new_event_list,
}, request)
def remove_project(request, project):
if project.is_default_project():
return HttpResponseRedirect(reverse('sentry-project-list'))
if not can_remove_project(request.user, project):
return HttpResponseRedirect(reverse('sentry'))
project_list = filter(lambda x: x != project,
get_project_list(request.user).itervalues())
form = RemoveProjectForm(request.user, project_list, request.POST or None)
if form.is_valid():
removal_type = form.cleaned_data['removal_type']
if removal_type == '1':
project.delete()
elif removal_type == '2':
new_project = form.cleaned_data['project']
project.merge_to(new_project)
elif removal_type == '3':
project.update(status=1)
else:
raise ValueError(removal_type)
return HttpResponseRedirect(reverse('sentry-project-list'))
context = csrf(request)
context.update({
'form': form,
'project': project,
})
return render_to_response('sentry/projects/remove.html', context, request)
def get_group_trends(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if project:
project_dict = {project.pk: project}
else:
project_dict = get_project_list(request.user)
base_qs = Group.objects.filter(
project__in=project_dict.keys(),
status=0,
)
if has_trending():
group_list = list(Group.objects.get_accelerated(base_qs, minutes=(
minutes
))[:limit])
else:
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(base_qs.filter(
last_seen__gte=cutoff_dt
).order_by('-score')[:limit])
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
data = to_json(group_list, request)
response = HttpResponse(data)
response['Content-Type'] = 'application/json'
return response
def dashboard(request):
project_list = get_project_list(request.user, key='slug')
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
if project_list:
cutoff = datetime.datetime.now() - datetime.timedelta(days=1)
base_qs = Group.objects.filter(
project__in=project_list.values(),
status=0,
).select_related('project').order_by('-score')
top_event_list = list(base_qs.filter(
last_seen__gte=cutoff
)[:10])
new_event_list = list(base_qs.filter(
first_seen__gte=cutoff,
)[:10])
else:
top_event_list = None
new_event_list = None
return render_to_response('sentry/dashboard.html', {
'top_event_list': top_event_list,
'new_event_list': new_event_list,
}, request)
def get_stats(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
if project:
project_list = [project]
else:
project_list = get_project_list(request.user).values()
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
num_events = ProjectCountByMinute.objects.filter(
project__in=project_list,
date__gte=cutoff_dt,
).aggregate(t=Sum('times_seen'))['t'] or 0
# XXX: This is too slow if large amounts of groups are resolved
num_resolved = Group.objects.filter(
project__in=project_list,
status=1,
resolved_at__gte=cutoff_dt,
).aggregate(t=Sum('times_seen'))['t'] or 0
data = {
'events': num_events,
'resolved': num_resolved,
}
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def remove_project(request, project):
if not can_remove_project(request.user, project):
return HttpResponseRedirect(reverse("sentry"))
project_list = filter(lambda x: x != project, get_project_list(request.user).itervalues())
form = RemoveProjectForm(request.user, project_list, request.POST or None)
if form.is_valid():
removal_type = form.cleaned_data["removal_type"]
if removal_type == "1":
project.delete()
elif removal_type == "2":
new_project = form.cleaned_data["project"]
project.merge_to(new_project)
elif removal_type == "3":
project.update(status=1)
else:
raise ValueError(removal_type)
return HttpResponseRedirect(reverse("sentry-project-list"))
context = csrf(request)
context.update({"form": form, "project": project})
return render_to_response("sentry/projects/remove.html", context, request)
def resolve(request, project):
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(request.user):
return HttpResponseForbidden()
Group.objects.filter(pk=group.pk).update(status=1)
group.status = 1
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}).strip(),
'count': m.times_seen,
}) for m in [group]]
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def get_new_groups(request, team=None, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if team:
project_dict = dict((p.id, p) for p in Project.objects.filter(team=team))
elif project:
project_dict = {project.id: project}
else:
project_dict = get_project_list(request.user)
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(Group.objects.filter(
project__in=project_dict.keys(),
status=STATUS_UNRESOLVED,
active_at__gte=cutoff_dt,
).extra(select={'sort_value': 'score'}).order_by('-score', '-first_seen')[:limit])
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
data = to_json(group_list, request)
response = HttpResponse(data)
response['Content-Type'] = 'application/json'
return response
def chart(request, team=None, project=None):
gid = request.REQUEST.get('gid')
days = int(request.REQUEST.get('days', '90'))
if gid:
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
data = Group.objects.get_chart_data(group, max_days=days)
elif project:
data = Project.objects.get_chart_data(project, max_days=days)
elif team:
cache_key = 'api.chart:team=%s,days=%s' % (team.id, days)
data = cache.get(cache_key)
if data is None:
project_list = list(Project.objects.filter(team=team))
data = Project.objects.get_chart_data_for_group(project_list, max_days=days)
cache.set(cache_key, data, 300)
else:
cache_key = 'api.chart:user=%s,days=%s' % (request.user.id, days)
data = cache.get(cache_key)
if data is None:
project_list = get_project_list(request.user).values()
data = Project.objects.get_chart_data_for_group(project_list, max_days=days)
cache.set(cache_key, data, 300)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def get_group_trends(request, project=None):
minutes = int(request.REQUEST.get("minutes", 15))
limit = min(100, int(request.REQUEST.get("limit", 10)))
if project:
project_dict = {project.pk: project}
else:
project_dict = get_project_list(request.user)
base_qs = Group.objects.filter(project__in=project_dict.keys(), status=0).order_by("-score")
if has_trending():
group_list = list(Group.objects.get_accelerated(base_qs, minutes=(minutes))[:limit])
else:
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(base_qs.filter(last_seen__gte=cutoff_dt)[:limit])
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
data = transform_groups(request, group_list, template="sentry/partial/_group_small.html")
response = HttpResponse(json.dumps(data))
response["Content-Type"] = "application/json"
return response
def dashboard(request):
project_list = get_project_list(request.user, key='slug')
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
return render_to_response('sentry/dashboard.html', {
}, request)
def _wrapped(request, project_id=None, *args, **kwargs):
# XXX: if project_id isn't set, should we only allow superuser?
if project_id.isdigit():
lookup_kwargs = {'id': int(project_id)}
else:
lookup_kwargs = {'slug': project_id}
if request.user.is_superuser:
if project_id:
try:
project = Project.objects.get_from_cache(**lookup_kwargs)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
if project_id:
key, value = lookup_kwargs.items()[0]
project_list = get_project_list(request.user, group_or_func, key=key)
try:
project = project_list[value]
except (KeyError, ValueError):
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
def get_group_trends(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if project:
project_list = [project]
else:
project_list = get_project_list(request.user).values()
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = datetime.datetime.now() - cutoff
base_qs = Group.objects.filter(
project__in=project_list,
status=0,
).select_related('project').order_by('-score')
if has_trending():
group_list = list(Group.objects.get_accelerated(base_qs, minutes=(
(cutoff.days * 1440) + (cutoff.seconds * 60)
))[:limit])
else:
group_list = list(base_qs.filter(
last_seen__gte=cutoff_dt
)[:limit])
data = transform_groups(request, group_list, template='sentry/partial/_group_small.html')
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def get_new_groups(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if project:
project_dict = {project.id: project}
else:
project_dict = get_project_list(request.user)
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(Group.objects.filter(
project__in=project_dict.keys(),
status=0,
active_at__gte=cutoff_dt,
).order_by('-score')[:limit])
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
data = to_json(group_list, request)
response = HttpResponse(data)
response['Content-Type'] = 'application/json'
return response
def bookmark(request, project):
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
if not request.user.is_authenticated():
return HttpResponseForbidden()
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(request.user):
return HttpResponseForbidden()
gb, created = GroupBookmark.objects.get_or_create(
project=group.project,
user=request.user,
group=group,
)
if not created:
gb.delete()
response = HttpResponse(json.dumps({'bookmarked': created}))
response['Content-Type'] = 'application/json'
return response
def dashboard(request):
project_list = get_project_list(request.user)
if len(project_list) == 1:
return HttpResponseRedirect(
reverse('sentry', kwargs={'project_id': project_list.keys()[0]}))
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
return render_to_response('sentry/dashboard.html', request=request)
def clear(request, project):
projects = get_project_list(request.user)
event_list = Group.objects.filter(Q(project__in=projects.keys()) | Q(project__isnull=True))
event_list.update(status=1)
data = []
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def dashboard(request):
project_list = get_project_list(request.user, key="slug")
has_projects = len(project_list) > 1 or (len(project_list) == 1 and project_list.values()[0].pk != settings.PROJECT)
if not has_projects:
if not request.user.is_authenticated():
request.session["_next"] = request.build_absolute_uri()
return HttpResponseRedirect(get_login_url())
elif can_create_projects(request.user):
return HttpResponseRedirect(reverse("sentry-new-project"))
return render_to_response("sentry/dashboard.html", {}, request)
def clear(request, project):
projects = get_project_list(request.user)
event_list = Group.objects.filter(
Q(project__in=projects.keys()) | Q(project__isnull=True))
event_list.update(status=1)
data = []
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def dashboard(request, template='dashboard.html'):
project_list = get_project_list(request.user, key='slug')
has_projects = len(project_list) > 1 or (len(project_list) == 1 and project_list.values()[0].pk != settings.PROJECT)
if not has_projects:
if not request.user.is_authenticated():
request.session['_next'] = request.get_full_path()
return HttpResponseRedirect(get_login_url())
elif can_create_projects(request.user):
return HttpResponseRedirect(reverse('sentry-new-project'))
return render_to_response('sentry/%s' % template, {}, request)
def project_list(request):
project_list = get_project_list(request.user, hidden=True)
memberships = list(ProjectMember.objects.filter(user=request.user, project__in=project_list))
for member in memberships:
project_id = member.project_id
project_list[project_id].member_dsn = member.get_dsn()
project_list[project_id].member_type = member.get_type_display()
return render_to_response('sentry/projects/list.html', {
'project_list': project_list.values(),
}, request)
def project_list(request):
project_list = get_project_list(request.user, hidden=True)
memberships = dict(
(p.project_id, p)
for p in ProjectMember.objects.filter(user=request.user, project__in=project_list)
)
for project_id, member in memberships.iteritems():
project_list[project_id].member_dsn = member.get_dsn(request.get_host(), secure=request.is_secure())
project_list[project_id].member_type = member.get_type_display()
return render_to_response('sentry/projects/list.html', {
'project_list': project_list.values(),
}, request)
def __init__(self, *args, **kwargs):
super(NotificationUserOptionsForm, self).__init__(*args, **kwargs)
user = self.user
self.project_list = get_project_list(user, access=MEMBER_USER, key='slug')
project_choices = sorted((p.slug, p.name) for p in self.project_list.values())
self.fields['projects'].choices = project_choices
self.fields['projects'].widget.choices = self.fields['projects'].choices
enabled_projects = []
for slug, project in self.project_list.iteritems():
is_enabled = self.plugin.get_option('alert', project=project, user=user)
if is_enabled == 1 or is_enabled is None:
enabled_projects.append(slug)
self.fields['projects'].initial = enabled_projects
def _wrapped(request, project_id=None, *args, **kwargs):
# If we're asking for anything other than implied access, the user
# must be authenticated
if group_or_func is not None and not request.user.is_authenticated(
):
request.session['_next'] = request.build_absolute_uri()
return HttpResponseRedirect(get_login_url())
# XXX: if project_id isn't set, should we only allow superuser?
if not project_id:
return func(request, None, *args, **kwargs)
if project_id.isdigit():
lookup_kwargs = {'id': int(project_id)}
else:
lookup_kwargs = {'slug': project_id}
if request.user.is_superuser:
if project_id:
try:
project = Project.objects.get_from_cache(
**lookup_kwargs)
except Project.DoesNotExist:
if project_id.isdigit():
# It could be a numerical slug
try:
project = Project.objects.get_from_cache(
slug=project_id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse('sentry'))
else:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
if project_id:
key, value = lookup_kwargs.items()[0]
project_list = get_project_list(request.user,
group_or_func,
key=key)
try:
project = project_list[value]
except KeyError:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
def __init__(self, *args, **kwargs):
super(NotificationUserOptionsForm, self).__init__(*args, **kwargs)
user = self.user
self.project_list = get_project_list(user, key='slug')
project_list = sorted(self.project_list.items())
self.fields['projects'].choices = project_list
self.fields['projects'].widget.choices = self.fields['projects'].choices
enabled_projects = []
for slug, project in project_list:
is_enabled = self.plugin.get_option('alert', project=project, user=user)
if is_enabled == 1 or is_enabled is None:
enabled_projects.append(slug)
self.fields['projects'].initial = enabled_projects
def dashboard(request, template='dashboard.html'):
project_list = get_project_list(request.user, key='slug')
has_projects = len(project_list) > 1 or (
len(project_list) == 1
and project_list.values()[0].pk != settings.PROJECT)
if not has_projects:
if not request.user.is_authenticated():
request.session['_next'] = request.get_full_path()
return HttpResponseRedirect(get_login_url())
elif can_create_projects(request.user):
return HttpResponseRedirect(reverse('sentry-new-project'))
return render_to_response('sentry/%s' % template, {}, request)
def project_list(request):
project_list = get_project_list(request.user, hidden=True).values()
team_list = dict((t.id, t) for t in Team.objects.filter(pk__in=[p.team_id for p in project_list]))
memberships = dict((tm.team_id, tm) for tm in TeamMember.objects.filter(user=request.user, team__in=team_list))
keys = dict((p.project_id, p) for p in ProjectKey.objects.filter(user=request.user, project__in=project_list))
for project in project_list:
key = keys.get(project.id)
if key:
project.member_dsn = key.get_dsn()
member = memberships.get(project.team_id)
if member:
project.member_type = member.get_type_display()
return render_to_response("sentry/projects/list.html", {"PROJECT_LIST": project_list}, request)
def _wrapped(request, project_id=None, *args, **kwargs):
# If we're asking for anything other than implied access, the user
# must be authenticated
if group_or_func is not None and not request.user.is_authenticated():
request.session['_next'] = request.build_absolute_uri()
return HttpResponseRedirect(get_login_url())
# XXX: if project_id isn't set, should we only allow superuser?
if not project_id:
return func(request, None, *args, **kwargs)
if project_id.isdigit():
lookup_kwargs = {'id': int(project_id)}
else:
lookup_kwargs = {'slug': project_id}
if request.user.is_superuser:
if project_id:
try:
project = Project.objects.get_from_cache(**lookup_kwargs)
except Project.DoesNotExist:
if project_id.isdigit():
# It could be a numerical slug
try:
project = Project.objects.get_from_cache(slug=project_id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse('sentry'))
else:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
if project_id:
key, value = lookup_kwargs.items()[0]
project_list = get_project_list(request.user, group_or_func, key=key)
try:
project = project_list[value]
except KeyError:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
def project_list(request):
project_list = get_project_list(request.user, hidden=True).values()
team_list = dict((t.id, t) for t in Team.objects.filter(pk__in=[p.team_id for p in project_list]))
memberships = dict((tm.team_id, tm) for tm in TeamMember.objects.filter(user=request.user, team__in=team_list))
keys = dict((p.project_id, p) for p in ProjectKey.objects.filter(user=request.user, project__in=project_list))
for project in project_list:
key = keys.get(project.id)
if key:
project.member_dsn = key.get_dsn()
member = memberships.get(project.team_id)
if member:
project.member_type = member.get_type_display()
return render_to_response('sentry/projects/list.html', {
'PROJECT_LIST': project_list,
}, request)
def chart(request, project):
gid = request.REQUEST.get('gid')
days = int(request.REQUEST.get('days', '90'))
if gid:
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(request.user):
return HttpResponseForbidden()
data = Group.objects.get_chart_data(group, max_days=days)
else:
data = Project.objects.get_chart_data(project, max_days=days)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def chart(request, project):
gid = request.REQUEST.get('gid')
days = int(request.REQUEST.get('days', '90'))
if gid:
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
if group.project and group.project.pk not in get_project_list(
request.user):
return HttpResponseForbidden()
data = Group.objects.get_chart_data(group, max_days=days)
else:
data = Project.objects.get_chart_data(project, max_days=days)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def _wrapped(request, project_id=None, *args, **kwargs):
# XXX: if project_id isn't set, should we only allow superuser?
if request.user.is_superuser:
if project_id:
try:
project = Project.objects.get(pk=project_id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
if project_id:
project_list = get_project_list(request.user, group_or_func)
try:
project = project_list[int(project_id)]
except (KeyError, ValueError):
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
def _wrapped(request, project_id=None, *args, **kwargs):
# XXX: if project_id isn't set, should we only allow superuser?
if request.user.is_superuser:
if project_id:
try:
project = Project.objects.get_from_cache(pk=project_id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
if project_id:
project_list = get_project_list(request.user, group_or_func)
try:
project = project_list[int(project_id)]
except (KeyError, ValueError):
return HttpResponseRedirect(reverse('sentry'))
else:
project = None
return func(request, project, *args, **kwargs)
def project_list(request):
project_list = get_project_list(request.user, hidden=True).values()
team_list = Team.objects.in_bulk([p.team_id for p in project_list])
if request.user.is_authenticated():
memberships = dict((tm.team_id, tm) for tm in TeamMember.objects.filter(user=request.user, team__in=team_list))
keys = dict((p.project_id, p) for p in ProjectKey.objects.filter(user=request.user, project__in=project_list))
else:
memberships = {}
keys = {}
for project in project_list:
key = keys.get(project.id)
if key:
project.member_dsn = key.get_dsn()
member = memberships.get(project.team_id)
if member:
project.member_type = member.get_type_display()
return render_to_response('sentry/projects/list.html', {
'PROJECT_LIST': project_list,
}, request)
def get_group_trends(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if project:
project_dict = {project.pk: project}
else:
project_dict = get_project_list(request.user)
base_qs = Group.objects.filter(
project__in=project_dict.keys(),
status=0,
)
if has_trending():
group_list = list(
Group.objects.get_accelerated(project_dict.keys(),
base_qs,
minutes=(minutes))[:limit])
else:
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = list(
base_qs.filter(
status=STATUS_UNRESOLVED,
last_seen__gte=cutoff_dt).order_by('-score')[:limit])
for group in group_list:
group._project_cache = project_dict.get(group.project_id)
data = to_json(group_list, request)
response = HttpResponse(data)
response['Content-Type'] = 'application/json'
return response
def get_resolved_groups(request, project=None):
minutes = int(request.REQUEST.get('minutes', 15))
limit = min(100, int(request.REQUEST.get('limit', 10)))
if project:
project_list = [project]
else:
project_list = get_project_list(request.user).values()
cutoff = datetime.timedelta(minutes=minutes)
cutoff_dt = timezone.now() - cutoff
group_list = Group.objects.filter(
project__in=project_list,
status=1,
resolved_at__gte=cutoff_dt,
).select_related('project').order_by('-score')[:limit]
data = to_json(group_list, request)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def chart(request, project=None):
gid = request.REQUEST.get('gid')
days = int(request.REQUEST.get('days', '90'))
if gid:
try:
group = Group.objects.get(pk=gid)
except Group.DoesNotExist:
return HttpResponseForbidden()
data = Group.objects.get_chart_data(group, max_days=days)
elif project:
data = Project.objects.get_chart_data(project, max_days=days)
else:
cache_key = 'api.chart:user=%s,days=%s' % (request.user.id, days)
data = cache.get(cache_key)
if data is None:
project_list = get_project_list(request.user).values()
data = Project.objects.get_chart_data_for_group(project_list, max_days=days)
cache.set(cache_key, data, 300)
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def project_list(request):
return render_to_response('sentry/projects/list.html', {
'project_list':
get_project_list(request.user, hidden=True).values(),
}, request)
def test_includes_public_projects_without_access(self):
project_list = get_project_list(self.user)
self.assertEquals(len(project_list), 1)
self.assertIn(self.project.id, project_list)
def test_does_exclude_public_projects_without_access(self):
project_list = get_project_list(self.user, MEMBER_USER)
self.assertEquals(len(project_list), 0)
def test_does_exclude_public_projects_but_include_private_with_access(self, get_for_user):
get_for_user.return_value = {self.project2.team.id: self.project2.team}
project_list = get_project_list(self.user, MEMBER_USER)
get_for_user.assert_called_once_with(self.user, MEMBER_USER)
self.assertEquals(len(project_list), 1)
self.assertIn(self.project2.id, project_list)
def dashboard(request):
project_list = get_project_list(request.user, key='slug')
if len(project_list) == 0 and not request.user.is_authenticated():
return HttpResponseRedirect(get_login_url())
return render_to_response('sentry/dashboard.html', {}, request)
