def dashboard(request, template='dashboard.html'):
team_list = Team.objects.get_for_user(request.user, with_projects=True)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry-new-team'))
return render_to_response('sentry/generic_error.html', {
'title': _('No Membership'),
'message': _('You are not a member of any teams in Sentry and you do not have access to create a new team.'),
}, request)
return render_to_response('sentry/select_team.html', {
'team_list': team_list.values(),
'can_create_teams': can_create_teams(request.user),
}, request)
def get_default_context(request, existing_context=None):
from sentry.plugins import plugins
context = {
'COMPRESS_ENABLED': dj_settings.COMPRESS_ENABLED,
'COMPRESS_LESS': dj_settings.COMPRESS_ENABLED and dj_settings.LESS_BIN,
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'INTERNAL_PROJECT': get_internal_project(),
'PROJECT_ID': str(settings.PROJECT),
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
'USE_JS_CLIENT': settings.USE_JS_CLIENT,
}
if request:
context.update({
'request': request,
'can_create_projects': can_create_projects(request.user),
'can_create_teams': can_create_teams(request.user),
})
if not existing_context or 'PROJECT_LIST' not in existing_context:
context['PROJECT_LIST'] = get_project_list(request.user).values()
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = Team.objects.get_for_user(
request.user).values()
return context
def create_new_team(request):
if not can_create_teams(request.user):
return missing_perm(request, Permissions.ADD_TEAM)
if request.user.has_perm('sentry.can_add_team'):
form_cls = NewTeamAdminForm
initial = {
'owner': request.user.username,
}
else:
form_cls = NewTeamForm
initial = {}
form = form_cls(request.POST or None, initial=initial)
if form.is_valid():
team = form.save(commit=False)
if not team.owner_id:
team.owner = request.user
team.save()
return HttpResponseRedirect(reverse('sentry-new-project', args=[team.slug]))
context = csrf(request)
context.update({
'form': form,
})
return render_to_response('sentry/teams/new.html', context, request)
def dashboard(request, template='dashboard.html'):
team_list = Team.objects.get_for_user(request.user)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry-new-team'))
return render_to_response(
'sentry/generic_error.html', {
'title':
_('No Membership'),
'message':
_('You are not a member of any teams in Sentry and you do not have access to create a new team.'
),
}, request)
# This cookie gets automatically set by render_to_response
if len(team_list) == 1:
team = team_list.values()[0]
return HttpResponseRedirect(reverse('sentry', args=[team.slug]))
# these kinds of queries make people sad :(
results = []
for team in sorted(team_list.itervalues(), key=lambda x: x.name):
project_list = list(
team.project_set.filter(
status=STATUS_VISIBLE, ).order_by('name')[:20])
results.append((team, project_list))
return render_to_response('sentry/select_team.html', {
'team_list': results,
}, request)
def get_default_context(request, existing_context=None, team=None):
from sentry.plugins import plugins
context = {
"HAS_SEARCH": settings.USE_SEARCH,
"MESSAGES_PER_PAGE": settings.MESSAGES_PER_PAGE,
"INTERNAL_PROJECT": get_internal_project(),
"PROJECT_ID": str(settings.PROJECT),
"URL_PREFIX": settings.URL_PREFIX,
"PLUGINS": plugins,
"USE_JS_CLIENT": settings.USE_JS_CLIENT,
}
if request:
context.update(
{
"request": request,
"can_create_projects": can_create_projects(request.user),
"can_create_teams": can_create_teams(request.user),
}
)
if team:
context.update({"can_admin_team": Team.objects.get_for_user(request.user, MEMBER_OWNER)})
if not existing_context or "PROJECT_LIST" not in existing_context:
project_list = Project.objects.get_for_user(request.user, team=team)
context["PROJECT_LIST"] = sorted(project_list, key=lambda x: x.name)
if not existing_context or "TEAM_LIST" not in existing_context:
context["TEAM_LIST"] = sorted(Team.objects.get_for_user(request.user).values(), key=lambda x: x.name)
return context
def create_new_team(request):
if not can_create_teams(request.user):
return missing_perm(request, Permissions.ADD_TEAM)
if request.user.is_superuser:
form_cls = NewTeamAdminForm
initial = {
'owner': request.user.username,
}
else:
form_cls = NewTeamForm
initial = {}
form = form_cls(request.POST or None, initial=initial)
if form.is_valid():
team = form.save(commit=False)
if not team.owner_id:
team.owner = request.user
team.save()
return HttpResponseRedirect(
reverse('sentry-new-project', args=[team.slug]))
context = csrf(request)
context.update({
'form': form,
})
return render_to_response('sentry/teams/new.html', context, request)
def dashboard(request, template='dashboard.html'):
team_list = Team.objects.get_for_user(request.user)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry-new-team'))
return render_to_response('sentry/generic_error.html', {
'title': _('No Membership'),
'message': _('You are not a member of any teams in Sentry and you do not have access to create a new team.'),
}, request)
# This cookie gets automatically set by render_to_response
if len(team_list) == 1:
team = team_list.values()[0]
return HttpResponseRedirect(reverse('sentry', args=[team.slug]))
# these kinds of queries make people sad :(
results = []
for team in sorted(team_list.itervalues(), key=lambda x: x.name):
project_list = list(team.project_set.filter(
status=STATUS_VISIBLE,
).order_by('name')[:20])
results.append((team, project_list))
return render_to_response('sentry/select_team.html', {
'team_list': results,
}, request)
def post(self, request, organization_slug):
organization = Organization.objects.get_from_cache(
slug=organization_slug, )
if not can_create_teams(request.user, organization):
return Response(status=403)
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
owner=result.get('owner') or organization.owner,
organization=organization,
)
AuditLogEntry.objects.create(
organization=organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_ADD,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_default_context(request, existing_context=None, team=None):
from sentry.plugins import plugins
context = {
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
}
if request:
context.update({
'request': request,
'can_create_teams': can_create_teams(request.user),
})
if team:
context.update({
'can_admin_team': Team.objects.get_for_user(request.user, MEMBER_OWNER),
'can_create_projects': can_create_projects(request.user, team=team),
})
else:
context['can_create_projects'] = can_create_projects(request.user)
if not existing_context or 'PROJECT_LIST' not in existing_context:
project_list = Project.objects.get_for_user(request.user, team=team)
context['PROJECT_LIST'] = sorted(project_list, key=lambda x: x.name)
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = sorted(Team.objects.get_for_user(request.user).values(), key=lambda x: x.name)
return context
def get_default_context(request, existing_context=None):
from sentry.plugins import plugins
context = {
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'PROJECT_ID': str(settings.PROJECT),
'VIEWS': list(View.objects.all()),
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
'USE_JS_CLIENT': settings.USE_JS_CLIENT,
}
if request:
context.update({
'request': request,
'can_create_projects': can_create_projects(request.user),
'can_create_teams': can_create_teams(request.user),
})
if not existing_context or 'PROJECT_LIST' not in existing_context:
context['PROJECT_LIST'] = get_project_list(request.user).values()
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = get_team_list(request.user).values()
return context
def get_default_context(request, existing_context=None):
from sentry.plugins import plugins
context = {
"HAS_SEARCH": settings.USE_SEARCH,
"MESSAGES_PER_PAGE": settings.MESSAGES_PER_PAGE,
"PROJECT_ID": str(settings.PROJECT),
"VIEWS": list(View.objects.all()),
"URL_PREFIX": settings.URL_PREFIX,
"PLUGINS": plugins,
"USE_JS_CLIENT": settings.USE_JS_CLIENT,
}
if request:
context.update(
{
"request": request,
"can_create_projects": can_create_projects(request.user),
"can_create_teams": can_create_teams(request.user),
}
)
if not existing_context or "PROJECT_LIST" not in existing_context:
context["PROJECT_LIST"] = get_project_list(request.user).values()
if not existing_context or "TEAM_LIST" not in existing_context:
context["TEAM_LIST"] = Team.objects.get_for_user(request.user).values()
return context
def create_new_team(request):
if not can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry'))
if request.user.has_perm('sentry.can_add_team'):
form_cls = NewTeamAdminForm
initial = {
'owner': request.user.username,
}
else:
form_cls = NewTeamForm
initial = {}
form = form_cls(request.POST or None, initial=initial)
if form.is_valid():
team = form.save(commit=False)
if not team.owner_id:
team.owner = request.user
team.save()
return HttpResponseRedirect(reverse('sentry-manage-team', args=[team.slug]))
context = csrf(request)
context.update({
'form': form,
})
return render_to_response('sentry/teams/new.html', context, request)
def new_project(request):
from django.contrib.auth.models import User
if not can_create_projects(request.user):
return HttpResponseRedirect(reverse('sentry'))
allow_create_teams = can_create_teams(request.user)
team_list = Team.objects.get_for_user(request.user)
if request.user.has_perm('sentry.can_add_project') and User.objects.all()[0:2] == 2:
project_form_cls = NewProjectAdminForm
project_initial = {
'owner': request.user.username,
}
else:
project_form_cls = NewProjectForm
project_initial = {}
if len(team_list) > 0:
select_team_form = SelectTeamForm(team_list, request.POST or None, prefix='st')
elif not allow_create_teams:
return render_to_response('sentry/projects/cannot_create_teams.html', {}, request)
else:
select_team_form = None
if allow_create_teams:
new_team_form = NewTeamForm(request.POST or None, prefix='nt')
else:
new_team_form = None
project_form = project_form_cls(request.POST or None, initial=project_initial, prefix='prj')
is_new_team = new_team_form and new_team_form.is_valid()
if is_new_team or not select_team_form:
team_form = new_team_form
else:
team_form = select_team_form
if project_form.is_valid() and team_form.is_valid():
project = project_form.save(commit=False)
if not project.owner:
project.owner = request.user
if is_new_team:
team = new_team_form.save(commit=False)
team.owner = project.owner
team.save()
else:
team = select_team_form.cleaned_data['team']
project.team = team
project.save()
return HttpResponseRedirect(reverse('sentry-get-started', args=[project.slug]))
return render_to_response('sentry/projects/new.html', {
'project_form': project_form,
'select_team_form': select_team_form,
'new_team_form': new_team_form,
}, request)
def get_default_context(request, existing_context=None):
from sentry.plugins import plugins
context = {
'COMPRESS_ENABLED': dj_settings.COMPRESS_ENABLED,
'COMPRESS_LESS': dj_settings.COMPRESS_ENABLED and dj_settings.LESS_BIN,
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'INTERNAL_PROJECT': get_internal_project(),
'PROJECT_ID': str(settings.PROJECT),
'VIEWS': list(View.objects.all()),
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
'USE_JS_CLIENT': settings.USE_JS_CLIENT,
}
if request:
context.update({
'request': request,
'can_create_projects': can_create_projects(request.user),
'can_create_teams': can_create_teams(request.user),
})
if not existing_context or 'PROJECT_LIST' not in existing_context:
context['PROJECT_LIST'] = get_project_list(request.user).values()
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = Team.objects.get_for_user(request.user).values()
return context
def post(self, request, organization_slug):
organization = Organization.objects.get_from_cache(
slug=organization_slug,
)
if not can_create_teams(request.user, organization):
return Response(status=403)
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
owner=result.get('owner') or organization.owner,
organization=organization,
)
AuditLogEntry.objects.create(
organization=organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_ADD,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_default_context(request, existing_context=None):
from sentry.plugins import plugins
context = {
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'PROJECT_ID': str(settings.PROJECT),
'VIEWS': list(View.objects.all()),
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
'USE_JS_CLIENT': settings.USE_JS_CLIENT,
}
if request:
context.update({
'request': request,
'can_create_projects': can_create_projects(request.user),
'can_create_teams': can_create_teams(request.user),
})
if not existing_context or 'PROJECT_LIST' not in existing_context:
context['PROJECT_LIST'] = get_project_list(request.user).values()
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = get_team_list(request.user).values()
return context
def new_project(request):
from django.contrib.auth.models import User
if not can_create_projects(request.user):
return HttpResponseRedirect(reverse('sentry'))
allow_create_teams = can_create_teams(request.user)
team_list = Team.objects.get_for_user(request.user)
if request.user.has_perm('sentry.can_add_project') and User.objects.all()[0:2] == 2:
project_form_cls = NewProjectAdminForm
project_initial = {
'owner': request.user.username,
}
else:
project_form_cls = NewProjectForm
project_initial = {}
if len(team_list) > 0:
select_team_form = SelectTeamForm(team_list, request.POST or None, prefix='st')
elif not allow_create_teams:
return render_to_response('sentry/projects/cannot_create_teams.html', {}, request)
else:
select_team_form = None
if allow_create_teams:
new_team_form = NewTeamForm(request.POST or None, prefix='nt')
else:
new_team_form = None
project_form = project_form_cls(request.POST or None, initial=project_initial, prefix='prj')
is_new_team = new_team_form and new_team_form.is_valid()
if is_new_team or not select_team_form:
team_form = new_team_form
else:
team_form = select_team_form
if project_form.is_valid() and team_form.is_valid():
project = project_form.save(commit=False)
if not project.owner:
project.owner = request.user
if is_new_team:
team = new_team_form.save(commit=False)
team.owner = project.owner
team.save()
else:
team = select_team_form.cleaned_data['team']
project.team = team
project.save()
return HttpResponseRedirect(reverse('sentry-project-client-help', args=[project.slug]))
return render_to_response('sentry/projects/new.html', {
'project_form': project_form,
'select_team_form': select_team_form,
'new_team_form': new_team_form,
}, request)
def handle(self, request, organization):
if not can_create_teams(request.user, organization):
return missing_perm(request, Permissions.ADD_TEAM)
session_data = request.session.get(self.session_key, {})
if request.method == 'GET':
logging.debug('GET request; resetting create team form wizard')
current_step = 0
try:
del request.session[self.session_key]
except KeyError:
pass
else:
current_step = int(request.POST.get('step', 0))
last_step = len(self.steps) - 1
if current_step > last_step:
logging.debug(
'Invalid step passed; resetting create team form wizard')
return self.render_validation_error(request, organization)
op = request.POST.get('op')
if op != 'continue':
data = None
else:
data = request.POST or None
form = self.get_step_form(current_step, data)
if op == 'continue' and form.is_valid():
session_data['step%d' % current_step] = form.cleaned_data
request.session[self.session_key] = session_data
if current_step == last_step:
# no more steps, render done view
return self.render_done(request, organization, form)
else:
# proceed to the next step
return self.render_next_step(request, organization,
current_step + 1)
elif op == 'back' and current_step > 0:
return self.render_next_step(request, organization,
current_step - 1)
elif op == 'skip' and current_step > 0:
session_data['step%d' % current_step] = {}
request.session[self.session_key] = session_data
if current_step == last_step:
# no more steps, render done view
return self.render_done(request, organization, form)
else:
# proceed to the next step
return self.render_next_step(request, organization,
current_step + 1)
return self.render(request, organization, current_step, form)
def new_project(request):
from django.contrib.auth.models import User
if not can_create_projects(request.user):
return HttpResponseRedirect(reverse("sentry"))
allow_create_teams = can_create_teams(request.user)
team_list = Team.objects.get_for_user(request.user)
if request.user.has_perm("sentry.can_add_project") and User.objects.all()[0:2] == 2:
project_form_cls = NewProjectAdminForm
project_initial = {"owner": request.user.username}
else:
project_form_cls = NewProjectForm
project_initial = {}
if len(team_list) > 0:
select_team_form = SelectTeamForm(team_list, request.POST or None, prefix="st")
elif not allow_create_teams:
return render_to_response("sentry/projects/cannot_create_teams.html", {}, request)
else:
select_team_form = None
if allow_create_teams:
new_team_form = NewTeamForm(request.POST or None, prefix="nt")
else:
new_team_form = None
project_form = project_form_cls(request.POST or None, initial=project_initial, prefix="prj")
is_new_team = new_team_form and new_team_form.is_valid()
if is_new_team or not select_team_form:
team_form = new_team_form
else:
team_form = select_team_form
if project_form.is_valid() and team_form.is_valid():
project = project_form.save(commit=False)
if not project.owner:
project.owner = request.user
if is_new_team:
team = new_team_form.save(commit=False)
team.owner = project.owner
team.save()
else:
team = select_team_form.cleaned_data["team"]
project.team = team
project.save()
return HttpResponseRedirect(reverse("sentry-project-client-help", args=[project.slug]))
return render_to_response(
"sentry/projects/new.html",
{"project_form": project_form, "select_team_form": select_team_form, "new_team_form": new_team_form},
request,
)
def dashboard(request, template='dashboard.html'):
team_list = Team.objects.get_for_user(request.user, with_projects=True)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry-new-team'))
return render_to_response(
'sentry/generic_error.html', {
'title':
_('No Membership'),
'message':
_('You are not a member of any teams in Sentry and you do not have access to create a new team.'
),
}, request)
return render_to_response(
'sentry/select_team.html', {
'team_list': team_list.values(),
'can_create_teams': can_create_teams(request.user),
}, request)
def handle(self, request, organization):
if not can_create_teams(request.user, organization):
return missing_perm(request, Permissions.ADD_TEAM)
session_data = request.session.get(self.session_key, {})
if request.method == 'GET':
logging.debug('GET request; resetting create team form wizard')
current_step = 0
try:
del request.session[self.session_key]
except KeyError:
pass
else:
current_step = int(request.POST.get('step', 0))
last_step = len(self.steps) - 1
if current_step > last_step:
logging.debug('Invalid step passed; resetting create team form wizard')
return self.render_validation_error(request, organization)
op = request.POST.get('op')
if op != 'continue':
data = None
else:
data = request.POST or None
form = self.get_step_form(current_step, data)
if op == 'continue' and form.is_valid():
session_data['step%d' % current_step] = form.cleaned_data
request.session[self.session_key] = session_data
if current_step == last_step:
# no more steps, render done view
return self.render_done(request, organization, form)
else:
# proceed to the next step
return self.render_next_step(request, organization, current_step + 1)
elif op == 'back' and current_step > 0:
return self.render_next_step(request, organization, current_step - 1)
elif op == 'skip' and current_step > 0:
session_data['step%d' % current_step] = {}
request.session[self.session_key] = session_data
if current_step == last_step:
# no more steps, render done view
return self.render_done(request, organization, form)
else:
# proceed to the next step
return self.render_next_step(request, organization, current_step + 1)
return self.render(request, organization, current_step, form)
def post(self, request):
if not can_create_teams(request.user):
return Response(status=403)
if request.user.is_superuser:
serializer = TeamAdminSerializer(data=request.DATA)
else:
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
owner=result.get('owner') or request.user,
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
if not can_create_teams(request.user):
return Response(status=403)
if request.user.is_superuser:
serializer = TeamAdminSerializer(data=request.DATA)
else:
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
owner=result.get('owner') or request.user,
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def dashboard(request, template="dashboard.html"):
team_list = Team.objects.get_for_user(request.user, with_projects=True)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse("sentry-new-team"))
return render_to_response(
"sentry/generic_error.html",
{
"title": _("No Membership"),
"message": _(
"You are not a member of any teams in Sentry and you do not have access to create a new team."
),
},
request,
)
return render_to_response("sentry/select_team.html", {"team_list": team_list.values()}, request)
def dashboard(request, template='dashboard.html'):
team_list = Team.objects.get_for_user(request.user)
if not team_list:
if can_create_teams(request.user):
return HttpResponseRedirect(reverse('sentry-new-team'))
return render_to_response('sentry/generic_error.html', {
'title': _('No Membership'),
'message': _('You are not a member of any teams in Sentry and you do not have access to create a new team.'),
}, request)
# This cookie gets automatically set by render_to_response
last_team = request.session.get('team')
if last_team in team_list:
team = team_list[last_team]
else:
team = team_list.values()[0]
# Redirect to first team
# TODO: maybe store this in a cookie and redirect to last seen team?
return HttpResponseRedirect(reverse('sentry', args=[team.slug]))
def post(self, request, organization):
"""
Create a new team
Create a new team bound to an organization.
{method} {path}
{{
"name": "My team"
}}
"""
if not can_create_teams(request.user, organization):
return Response(status=403)
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result["name"],
slug=result.get("slug"),
owner=result.get("owner") or organization.owner,
organization=organization,
)
AuditLogEntry.objects.create(
organization=organization,
actor=request.user,
ip_address=request.META["REMOTE_ADDR"],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_ADD,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_new_team(request):
if not can_create_teams(request.user):
return HttpResponseRedirect(reverse("sentry"))
if request.user.has_perm("sentry.can_add_team"):
form_cls = NewTeamAdminForm
initial = {"owner": request.user.username}
else:
form_cls = NewTeamForm
initial = {}
form = form_cls(request.POST or None, initial=initial)
if form.is_valid():
team = form.save(commit=False)
if not team.owner_id:
team.owner = request.user
team.save()
return HttpResponseRedirect(reverse("sentry-manage-team", args=[team.slug]))
context = csrf(request)
context.update({"form": form})
return render_to_response("sentry/teams/new.html", context, request)
def post(self, request, organization):
"""
Create a new team
Create a new team bound to an organization.
{method} {path}
{{
"name": "My team"
}}
"""
if not can_create_teams(request.user, organization):
return Response(status=403)
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
organization=organization,
)
AuditLogEntry.objects.create(
organization=organization,
actor=request.user,
ip_address=request.META['REMOTE_ADDR'],
target_object=team.id,
event=AuditLogEntryEvent.TEAM_ADD,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_default_context(request, existing_context=None, team=None):
from sentry.plugins import plugins
context = {
'COMPRESS_ENABLED': dj_settings.COMPRESS_ENABLED,
'COMPRESS_LESS': dj_settings.COMPRESS_ENABLED and dj_settings.LESS_BIN,
'HAS_SEARCH': settings.USE_SEARCH,
'MESSAGES_PER_PAGE': settings.MESSAGES_PER_PAGE,
'INTERNAL_PROJECT': get_internal_project(),
'PROJECT_ID': str(settings.PROJECT),
'URL_PREFIX': settings.URL_PREFIX,
'PLUGINS': plugins,
'USE_JS_CLIENT': settings.USE_JS_CLIENT,
}
if request:
context.update({
'request': request,
'can_create_projects': can_create_projects(request.user),
'can_create_teams': can_create_teams(request.user),
})
if team:
context.update({
'can_admin_team': Team.objects.get_for_user(request.user, MEMBER_OWNER)
})
if not existing_context or 'PROJECT_LIST' not in existing_context:
if team:
project_list = Project.objects.filter(team=team)
else:
project_list = get_project_list(request.user).values()
context['PROJECT_LIST'] = sorted(project_list, key=lambda x: x.name)
if not existing_context or 'TEAM_LIST' not in existing_context:
context['TEAM_LIST'] = sorted(Team.objects.get_for_user(request.user).values(), key=lambda x: x.name)
return context
def post(self, request, organization):
"""
Create a new team
Create a new team bound to an organization.
{method} {path}
{{
"name": "My team"
}}
"""
if not can_create_teams(request.user, organization):
return Response(status=403)
serializer = TeamSerializer(data=request.DATA)
if serializer.is_valid():
result = serializer.object
team = Team.objects.create(
name=result['name'],
slug=result.get('slug'),
organization=organization,
)
self.create_audit_entry(
request=request,
organization=organization,
target_object=team.id,
event=AuditLogEntryEvent.TEAM_ADD,
data=team.get_audit_log_data(),
)
return Response(serialize(team, request.user), status=201)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
"""
sentry.templatetags.sentry_permissions
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
from django import template
from sentry.permissions import (
can_create_organizations, can_create_teams, can_create_projects,
can_remove_project, can_manage_project, can_manage_team, can_manage_org
)
register = template.Library()
# TODO: Django doesn't seem to introspect function args correctly for filters
# so we can't just register.filter(can_add_team_member)
register.filter('can_create_organizations')(lambda a: can_create_organizations(a))
register.filter('can_create_teams')(lambda a, b: can_create_teams(a, b))
register.filter('can_create_projects')(lambda a, b: can_create_projects(a, b))
register.filter('can_manage_team')(lambda a, b: can_manage_team(a, b))
register.filter('can_manage_project')(lambda a, b: can_manage_project(a, b))
register.filter('can_manage_org')(lambda a, b: can_manage_org(a, b))
register.filter('can_remove_project')(lambda a, b: can_remove_project(a, b))
"""
sentry.templatetags.sentry_permissions
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
from django import template
from sentry.permissions import (can_create_organizations, can_create_teams,
can_create_projects, can_remove_project,
can_manage_project, can_manage_team,
can_manage_org)
register = template.Library()
# TODO: Django doesn't seem to introspect function args correctly for filters
# so we can't just register.filter(can_add_team_member)
register.filter('can_create_organizations')(
lambda a: can_create_organizations(a))
register.filter('can_create_teams')(lambda a, b: can_create_teams(a, b))
register.filter('can_create_projects')(lambda a, b: can_create_projects(a, b))
register.filter('can_manage_team')(lambda a, b: can_manage_team(a, b))
register.filter('can_manage_project')(lambda a, b: can_manage_project(a, b))
register.filter('can_manage_org')(lambda a, b: can_manage_org(a, b))
register.filter('can_remove_project')(lambda a, b: can_remove_project(a, b))
