def test_func(self):
try:
get_r_object_or_404(self.request.user, Project,
name_short=self.kwargs.get('project')).developer_allowed(self.request.user)
except:
return 0
return 1
def test_func(self):
try:
get_r_object_or_404(self.request.user, Project,
name_short=self.kwargs.get('project'))
except Http404:
return 0
return 1
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
proj = get_r_object_or_404(self.request.user, Project, name_short=self.kwargs.get('project'))
sprint = get_r_object_or_404(self.request.user, Sprint, project__name_short=self.kwargs.get('project'),
seqnum=self.kwargs.get('sqn_s'))
context['project'] = proj
context['sprint'] = sprint
return context
def get_context_data(self, **kwargs):
# get the user for this profile page
user = get_r_object_or_404(self.request.user, get_user_model(), username=self.kwargs.get("username"))
# get the actor stream for the requested user profile
item_list = cache.get('activity_items_actor_'+user.username)
if not item_list:
item_list = actor_stream(user)
cache.set('activity_items_actor_'+user.username, item_list, 60*60*24*31)
# filter out actions with targets the requesting user is not part of
self.item_list = check_activity_permissions(self.request.user, item_list)
# get this user
selfuser = get_r_object_or_404(self.request.user, get_user_model(), username=self.request.user.username)
sharedprojects = Project.objects.filter(developer=user).filter(developer=selfuser)
sharedissues = Issue.objects.filter(assignee=user).filter(assignee=selfuser)
# create the context
context = super(ShowProfilePageView, self).get_context_data(**kwargs)
context['sharedprojects'] = sharedprojects
context['sharedissues'] = sharedissues
context['nocollapse'] = self.request.session.get('nocollapse', '')
if context['nocollapse'] != '':
del self.request.session['nocollapse']
# add data for notifications
prefs = {}
try:
prefs = json.loads(user.get_preference('notify_mail'))
except (TypeError, json.JSONDecodeError):
pass
# there shall be an entry for every project the user is member of
for uproj in user.get_projects():
if uproj.name_short not in prefs:
prefs[uproj.name_short] = []
context['notify_mail'] = prefs
notitypes = []
for t in Notitype.NOTI_TYPES:
notitypes.append([t[0], t[1]])
context['possible_notis'] = notitypes
# add data for activity chart type
if self.request.GET.get('data') is not None:
self.request.user.set_preference('activity_chart_type',
self.request.GET.get('data'))
data = self.request.user.get_preference('activity_chart_type',
default="timelog")
context['chart_type'] = data
return context
def test_func(self):
# allow access for managers and developers
try:
get_r_object_or_404(self.request.user, Repository,
project__name_short=self.kwargs.get('project'),
pk=self.kwargs.get('repository'),
)
except Http404:
return 0
return 1
def get(self, *args, **kwargs):
issue = get_r_object_or_404(self.request.user, Issue,
project__name_short=kwargs.get('project'), number=kwargs.get('sqn_i'))
notification = self.request.user.notifications.filter(issue=issue)
if notification:
notification.get().delete()
return super(IssueDetailView, self).get(*args, **kwargs)
def test_func(self):
return get_r_object_or_404(
self.request.user,
Sprint,
project__name_short=self.kwargs.get('project'),
seqnum=self.kwargs.get('sqn_s')).project.developer_allowed(
self.request.user)
def post(self, request, *args, **kwargs):
proj = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
if proj.has_active_sprint():
messages.add_message(
request, messages.ERROR,
_('Only one current sprint is allowed at once, ' +
'please finish your current running sprint first.'))
return redirect(
reverse('issue:backlog',
kwargs={
'project': self.kwargs.get('project'),
'sqn_s': self.kwargs.get('sqn_s')
}))
relsprint = Sprint.objects.get(
project__name_short=self.kwargs.get('project'),
seqnum=self.kwargs.get('sqn_s'))
relsprint.set_active()
proj.currentsprint = relsprint
proj.save()
signals.start.send(sender=relsprint.__class__,
instance=relsprint,
user=self.request.user)
return redirect(
reverse('issue:backlog',
kwargs={
'project': self.kwargs.get('project'),
'sqn_s': self.kwargs.get('sqn_s')
}))
def get_queryset(self):
if not self.request.user.is_authenticated or not self.kwargs or not self.kwargs.get(
'project'):
return Issue.objects.none()
project = self.kwargs.get('project')
try:
proj = get_r_object_or_404(self.request.user,
Project,
name_short=project)
except Http404:
return Issue.objects.none()
# get all issues of the project
# first list the not-archived ones
qs = proj.issue.all().order_by("archived")
if self.kwargs.get('issue') is not None:
# this happens in the issue edit view
# the issue should not refer to itself, so exclude it
issue = self.kwargs.get('issue')
qs = qs.exclude(project__name_short=project, number=issue)
if self.q:
qs = qs.filter(
Q(title__icontains=self.q) | Q(number__icontains=self.q))
return qs
def test_func(self):
# NOTE: even manager are not allowed to change/delete comments of other users
return get_r_object_or_404(self.request.user, Comment,
issue__project__name_short=self.kwargs.get('project'),
issue__number=self.kwargs.get('sqn_i'),
seqnum=self.kwargs.get('pk_c')
).user_has_write_permissions(self.request.user)
def post(self, request, *args, **kwargs):
project = get_r_object_or_404(self.request.user, Project, name_short=self.kwargs.get('project'))
form = self.form_class(request.POST, project=project)
if 'delete_tags' in request.POST:
for tag in request.POST.getlist('delete_tags'):
Tag.objects.filter(tag_text=tag, project=project).delete()
return HttpResponseRedirect(reverse('tag:tag', kwargs={'project': self.kwargs.get('project')}),
{'form': self.form_class(project=project)})
if form.is_valid():
if 'create_tag' in request.POST:
if len(request.POST['color']) > 0 and request.POST['color'] != "i dont care":
new_tag = Tag(tag_text=request.POST['tag_text'], color=request.POST['color'], project=project)
else:
new_tag = Tag(tag_text=request.POST['tag_text'], project=project)
new_tag.save()
return HttpResponseRedirect(reverse('tag:tag', kwargs={'project': self.kwargs.get('project')}),
{'form': form})
if request.is_ajax():
return HttpResponse(form.errors.as_json(), status=500, content_type='application/json')
tags = Tag.objects.filter(project=project)
return render(request, 'tag/tag_manage.html', {'form': form,
'project': project, 'tags': tags})
def get_sprint_issues(self):
proj = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
issues = proj.issue.filter(
sprint__seqnum=self.get_sqn_s()).not_archived()
return self._filter_issues(issues)
def test_func(self):
# allow access for managers and developers
return get_r_object_or_404(
self.request.user,
Project,
name_short=self.kwargs.get('project'),
).developer_allowed(self.request.user)
def post(self, request, *args, **kwargs):
proj = Project.objects.get(name_short=self.kwargs.get('project'))
sprint = Sprint.objects.filter(project__name_short=self.kwargs.get('project')) \
.get(seqnum=self.kwargs.get('sqn_s'))
sprint.set_inactive()
signals.stop.send(sender=sprint.__class__, instance=sprint, user=self.request.user)
new_sprint = request.POST.get('sprint')
if not new_sprint:
return redirect(reverse('backlog:backlog', kwargs={'project': self.kwargs.get('project')}))
selection = request.POST.getlist('move_to_new_sprint')
sprint = None
if new_sprint == 'new':
if selection:
sprint = Sprint(project=proj)
sprint.save()
else:
sprint = get_r_object_or_404(self.request.user, Sprint, project=proj, seqnum=new_sprint)
for issue in proj.issue.filter(number__in=selection):
issue.sprint = sprint
issue.save()
if selection:
return redirect(reverse('backlog:backlog', kwargs={'project': self.kwargs.get('project'),
'sqn_s': sprint.seqnum
}))
return redirect(reverse('backlog:backlog', kwargs={'project': self.kwargs.get('project')}))
def get_object(self):
return get_r_object_or_404(
self.request.user,
Repository,
project__name_short=self.kwargs.get('project'),
pk=self.kwargs.get('repository'),
)
def get_context_data(self, **kwargs):
context = super(ProjectDetailTimelogView,
self).get_context_data(**kwargs)
context['project'] = get_r_object_or_404(
self.request.user, Project, name_short=self.kwargs.get('project'))
devs = context['project'].get_members()
context['logs'] = []
devs = serializers.serialize("json", devs, fields=('username'))
devs = json.loads(devs)
for dev in devs:
logs = Timelog.objects.filter(
user=dev['pk'],
issue__project=context['project']).order_by('-created_at')
total_time = timedelta(0)
for l in logs:
total_time += l.time
dev['fields']['total'] = total_time
dev['fields']['logs'] = logs[:5]
dev['fields']['ava_url'] = context['project'].get_members().filter(
username=dev['fields']['username']).first().avatar.url
context['developer'] = sorted(devs,
key=lambda dev: dev['fields']['total'],
reverse=True)
return context
def d3_json_activity(request):
if not request.user.is_authenticated:
resp = json.dumps("login!")
return HttpResponse(resp, content_type='application/json')
proj = request.GET.get('project', None)
project = Project.objects.filter(name_short=proj)
if project.exists() and project.first().developer_allowed(request.user):
project = project.first()
else:
project = None
data_type = request.GET.get('data', None)
user = request.GET.get('user', request.user.username)
user = get_r_object_or_404(request.user, get_user_model(), username=user)
if not user.show_activity_to_other_users and user != request.user:
return HttpResponse(json.dumps(""), content_type='application/json')
if data_type == 'actions':
result = get_action_data(project, user)
else:
result = get_timelog_data(project, user)
resp = json.dumps(result)
return HttpResponse(resp, content_type='application/json')
def form_valid(self, form):
# set project for repository link
form.instance.project = get_r_object_or_404(self.request.user, Project,
name_short=self.kwargs.get('project'),
)
form.save()
return super(RepositoryCreateView, self).form_valid(form)
def get_context_data(self, *args, **kwargs):
context = super(IssueDetailView,
self).get_context_data(*args, **kwargs)
context['project'] = get_r_object_or_404(
self.request.user, Project, name_short=self.kwargs['project'])
issue = self.get_object()
context['issue'] = issue
# check the order of the comments
userSetting = self.request.user.get_preference("issue_comment-order",
default="oldest")
requestSetting = self.request.GET.get('order_by')
if requestSetting == "newest" or\
(requestSetting is None and userSetting == "newest"):
# order the comments by the newest
context['comments'] = issue.comments.order_by('-when').all()
context['comment_order'] = "newest"
else:
# order the comments by the oldest (default in the database)
context['comments'] = issue.comments.all()
context['comment_order'] = "oldest"
# save the setting to the user model
if userSetting != context['comment_order']:
self.request.user.set_preference("issue_comment-order",
context['comment_order'])
return context
def post(self, request, *args, **kwargs):
project = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
try:
expression = self.request.POST.get('expression').strip()
parser.compile(expression, project, self.request.user)
# add to sprint if currentsprint is set and issue was newly created
if self.request.POST.get(
'currentsprint') != "" and parser.issue_created:
sprint = Sprint.objects.get(
project__name_short=self.kwargs.get('project'),
seqnum=self.request.POST.get('currentsprint'))
parser.issue_to_change.sprint = sprint
parser.issue_to_change.save()
except Exception as e:
messages.add_message(
request, messages.ERROR,
_("An error occurred when processing your request") + ": " +
str(e))
# store expression in session data to give edit ability to user
self.request.session['oleaexpression'] = self.request.POST.get(
'expression')
# set focus to olea bar
self.request.session['oleafocus'] = 'autofocus'
return redirect(self.request.POST.get('next'))
def post(self, request, *args, **kwargs):
proj = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
issues = Issue.objects.filter(
project=proj, kanbancol__position=self.request.POST.get(
'pos_c')).without_sprint().not_archived()
if self.request.POST.get('filter') == 'true':
issues = issues.filter(assignee=self.request.user)
count = issues.count()
if count == 0:
messages.add_message(
request,
messages.ERROR,
_('No issues to archive'),
)
else:
messages.add_message(
request,
messages.ERROR,
str(count) + _(' issues moved to archive'),
)
for issue in issues:
issue.archived = True
issue.save()
success_url = self.get_success_url()
return HttpResponseRedirect(success_url)
def get_sprint_issues_left(self):
sprint = get_r_object_or_404(
self.request.user,
Sprint,
project__name_short=self.kwargs['project'],
seqnum=self.get_sqn_s())
return sprint.issues_left()
def get_object(self):
return get_r_object_or_404(
self.request.user,
Timelog,
issue__project__name_short=self.kwargs.get('project'),
issue__number=self.kwargs.get('sqn_i'),
number=self.kwargs.get('sqn_l'))
def test_func(self):
return get_r_object_or_404(
self.request.user,
Attachment,
issue__project__name_short=self.kwargs.get('project'),
issue__number=self.kwargs.get('sqn_i'),
seqnum=self.kwargs.get('sqn_a')).user_has_write_permissions(
self.request.user)
def post(self, request, *args, **kwargs):
relassignee = self.request.user
relissue = get_r_object_or_404(self.request.user, Issue,
project__name_short=self.kwargs.get('project'),
number=self.request.POST.get('sqn_i')
)
relissue.assignee.add(relassignee)
return redirect(self.get_success_url())
def get(self, request, *args, **kwargs):
attachment = get_r_object_or_404(
self.request.user,
Attachment,
issue__project__name_short=self.kwargs.get('project'),
issue__number=self.kwargs.get('sqn_i'),
seqnum=self.kwargs.get('sqn_a'))
return sendfile(request, attachment.file.path, attachment=False)
def dispatch(self, request, *args, **kwargs):
proj = get_r_object_or_404(self.request.user, Project, name_short=self.kwargs.get('project'))
if not request.user.is_authenticated:
return super(ProjectDetailTimelogView, self).dispatch(request, *args, **kwargs)
elif proj.activity_only_for_managers and not proj.is_manager(self.request.user):
return HttpResponseRedirect(reverse_lazy('project:usertimelog',
kwargs={'project': proj.name_short, 'username': self.request.user.username}
))
return super(ProjectDetailTimelogView, self).dispatch(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
project = get_r_object_or_404(self.request.user, Project,
name_short=self.kwargs.get('project'),
)
return TemplateResponse(request,
self.template_name,
{'searches': project.searches.all(),
'project': project,
})
def post(self, request, *args, **kwargs):
issue = get_r_object_or_404(self.request.user, Issue,
project__name_short=self.kwargs.get('project'),
number=self.request.POST.get('sqn_i')
)
issue.archived = True
issue.save()
success_url = self.get_success_url()
return HttpResponseRedirect(success_url)
def test_func(self):
# allow access for managers and developers
try:
repo = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
except Http404:
return 0
return 1
