def _bulk_update_order(self, order_field, request, **kwargs):
validator = validators.UpdateUserStoriesOrderBulkValidator(data=request.DATA)
if not validator.is_valid():
return response.BadRequest(validator.errors)
data = validator.data
project = get_object_or_404(Project, pk=data["project_id"])
status = None
status_id = data.get("status_id", None)
if status_id is not None:
status = get_object_or_404(UserStoryStatus, pk=status_id)
milestone = None
milestone_id = data.get("milestone_id", None)
if milestone_id is not None:
milestone = get_object_or_404(Milestone, pk=milestone_id)
self.check_permissions(request, "bulk_update_order", project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
ret = services.update_userstories_order_in_bulk(data["bulk_stories"],
order_field,
project,
status=status,
milestone=milestone)
return response.Ok(ret)
def by_slug(self, request):
iframe_slug = request.QUERY_PARAMS.get("slug", None)
project_slug = request.QUERY_PARAMS.get("pslug", None)
if iframe_slug and project_slug:
iframe = get_object_or_404(IframePlugin, slug=iframe_slug,
project__slug=project_slug)
return self.retrieve(request, pk=iframe.pk)
if project_slug: # no iframe slug, return iframes for this project
project = get_object_or_404(Project, slug=project_slug)
self.queryset = IframePlugin.objects.filter(
project__slug=project.slug)
return self.list(IframePlugin, request)
raise Http404(self.empty_error)
def bulk_update_milestone(self, request, **kwargs):
validator = validators.UpdateMilestoneBulkValidator(data=request.DATA)
if not validator.is_valid():
return response.BadRequest(validator.errors)
data = validator.data
project = get_object_or_404(Project, pk=data["project_id"])
milestone = get_object_or_404(Milestone, pk=data["milestone_id"])
self.check_permissions(request, "bulk_update_milestone", project)
ret = services.update_issues_milestone_in_bulk(data["bulk_issues"], milestone)
return response.Ok(ret)
def bulk_update_milestone(self, request, **kwargs):
serializer = serializers.UpdateMilestoneBulkSerializer(data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = get_object_or_404(Project, pk=data["project_id"])
milestone = get_object_or_404(Milestone, pk=data["milestone_id"])
self.check_permissions(request, "bulk_update_milestone", project)
services.update_userstories_milestone_in_bulk(data["bulk_stories"], milestone)
services.snapshot_userstories_in_bulk(data["bulk_stories"], request.user)
return response.NoContent()
def downvote(self, request, pk=None):
issue = get_object_or_404(models.Issue, pk=pk)
self.check_permissions(request, 'downvote', issue)
votes_service.remove_vote(issue, user=request.user)
return response.Ok()
def watched(self, request, *args, **kwargs):
for_user = get_object_or_404(models.User, **kwargs)
from_user = request.user
self.check_permissions(request, 'watched', for_user)
filters = {
"type": request.GET.get("type", None),
"q": request.GET.get("q", None),
}
self.object_list = services.get_watched_list(for_user, from_user, **filters)
page = self.paginate_queryset(self.object_list)
elements = page.object_list if page is not None else self.object_list
extra_args_liked = {
"user_watching": services.get_watched_content_for_user(request.user),
"user_likes": services.get_liked_content_for_user(request.user),
}
extra_args_voted = {
"user_watching": services.get_watched_content_for_user(request.user),
"user_votes": services.get_voted_content_for_user(request.user),
}
response_data = []
for elem in elements:
if elem["type"] == "project":
# projects are liked objects
response_data.append(serializers.LikedObjectSerializer(elem, **extra_args_liked).data )
else:
# stories, tasks and issues are voted objects
response_data.append(serializers.VotedObjectSerializer(elem, **extra_args_voted).data )
return response.Ok(response_data)
def stats(self, request, pk=None):
milestone = get_object_or_404(models.Milestone, pk=pk)
self.check_permissions(request, "stats", milestone)
total_points = milestone.total_points
milestone_stats = {
'name': milestone.name,
'estimated_start': milestone.estimated_start,
'estimated_finish': milestone.estimated_finish,
'total_points': total_points,
'completed_points': milestone.closed_points.values(),
'total_userstories': milestone.user_stories.count(),
'completed_userstories': len([us for us in milestone.user_stories.all() if us.is_closed]),
'total_tasks': milestone.tasks.all().count(),
'completed_tasks': milestone.tasks.all().filter(status__is_closed=True).count(),
'iocaine_doses': milestone.tasks.filter(is_iocaine=True).count(),
'days': []
}
current_date = milestone.estimated_start
sumTotalPoints = sum(total_points.values())
optimal_points = sumTotalPoints
milestone_days = (milestone.estimated_finish - milestone.estimated_start).days
optimal_points_per_day = sumTotalPoints / milestone_days if milestone_days else 0
while current_date <= milestone.estimated_finish:
milestone_stats['days'].append({
'day': current_date,
'name': current_date.day,
'open_points': sumTotalPoints - sum(milestone.closed_points_by_date(current_date).values()),
'optimal_points': optimal_points,
})
current_date = current_date + datetime.timedelta(days=1)
optimal_points -= optimal_points_per_day
return response.Ok(milestone_stats)
def retrieve(self, request, pk, *args, **kwargs):
throttle = throttling.ImportDumpModeRateThrottle()
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait())
project = get_object_or_404(self.get_queryset(), pk=pk)
self.check_permissions(request, 'export_project', project)
dump_format = request.QUERY_PARAMS.get("dump_format", "plain")
if settings.CELERY_ENABLED:
task = tasks.dump_project.delay(request.user, project, dump_format)
tasks.delete_project_dump.apply_async((project.pk, project.slug, task.id, dump_format),
countdown=settings.EXPORTS_TTL)
return response.Accepted({"export_id": task.id})
if dump_format == "gzip":
path = "exports/{}/{}-{}.json.gz".format(project.pk, project.slug, uuid.uuid4().hex)
storage_path = default_storage.path(path)
with default_storage.open(storage_path, mode="wb") as outfile:
services.render_project(project, gzip.GzipFile(fileobj=outfile))
else:
path = "exports/{}/{}-{}.json".format(project.pk, project.slug, uuid.uuid4().hex)
storage_path = default_storage.path(path)
with default_storage.open(storage_path, mode="wb") as outfile:
services.render_project(project, outfile)
response_data = {
"url": default_storage.url(path)
}
return response.Ok(response_data)
def duplicate(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "duplicate", project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
validator = validators.DuplicateProjectValidator(data=request.DATA)
if not validator.is_valid():
return response.BadRequest(validator.errors)
data = validator.data
# Validate if the project can be imported
is_private = data.get('is_private', False)
total_memberships = len(data.get("users", [])) + 1
(enough_slots, error_message) = users_services.has_available_slot_for_new_project(
self.request.user,
is_private,
total_memberships
)
if not enough_slots:
raise exc.NotEnoughSlotsForProject(is_private, total_memberships, error_message)
new_project = services.duplicate_project(
project=project,
owner=request.user,
name=data["name"],
description=data["description"],
is_private=data["is_private"],
users=data["users"]
)
new_project = get_object_or_404(self.get_queryset(), id=new_project.id)
serializer = self.get_serializer(new_project)
return response.Created(serializer.data)
def bulk_create(self, request, **kwargs):
validator = validators.CreateRelatedUserStoriesBulkValidator(data=request.DATA)
if not validator.is_valid():
return response.BadRequest(validator.errors)
data = validator.data
epic = get_object_or_404(models.Epic, id=kwargs["epic"])
project = Project.objects.get(pk=data.get('project_id'))
self.check_permissions(request, 'bulk_create', project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
related_userstories = services.create_related_userstories_in_bulk(
data["bulk_userstories"],
epic,
project=project,
owner=request.user
)
for related_userstory in related_userstories:
self.persist_history_snapshot(obj=related_userstory)
self.persist_history_snapshot(obj=related_userstory.user_story)
related_uss_serialized = self.get_serializer_class()(epic.relateduserstory_set.all(), many=True)
return response.Ok(related_uss_serialized.data)
def favourites(self, request, *args, **kwargs):
for_user = get_object_or_404(models.User, **kwargs)
from_user = request.user
self.check_permissions(request, 'favourites', for_user)
filters = {
"type": request.GET.get("type", None),
"action": request.GET.get("action", None),
"q": request.GET.get("q", None),
}
self.object_list = services.get_favourites_list(for_user, from_user, **filters)
page = self.paginate_queryset(self.object_list)
extra_args = {
"many": True,
"user_votes": services.get_voted_content_for_user(request.user),
"user_watching": services.get_watched_content_for_user(request.user),
}
if page is not None:
serializer = serializers.FavouriteSerializer(page.object_list, **extra_args)
else:
serializer = serializers.FavouriteSerializer(self.object_list, **extra_args)
return response.Ok(serializer.data)
def list(self, request, *args, **kwargs):
resource_id = kwargs.get("resource_id", None)
resource = get_object_or_404(self.resource_model, pk=resource_id)
self.check_permissions(request, 'list', resource)
return super().list(request, *args, **kwargs)
def filters_data(self, request, *args, **kwargs):
project_id = request.QUERY_PARAMS.get("project", None)
project = get_object_or_404(Project, id=project_id)
filter_backends = self.get_filter_backends()
types_filter_backends = (f for f in filter_backends if f != filters.IssueTypesFilter)
statuses_filter_backends = (f for f in filter_backends if f != filters.StatusesFilter)
assigned_to_filter_backends = (f for f in filter_backends if f != filters.AssignedToFilter)
owners_filter_backends = (f for f in filter_backends if f != filters.OwnersFilter)
priorities_filter_backends = (f for f in filter_backends if f != filters.PrioritiesFilter)
severities_filter_backends = (f for f in filter_backends if f != filters.SeveritiesFilter)
roles_filter_backends = (f for f in filter_backends if f != filters.RoleFilter)
queryset = self.get_queryset()
querysets = {
"types": self.filter_queryset(queryset, filter_backends=types_filter_backends),
"statuses": self.filter_queryset(queryset, filter_backends=statuses_filter_backends),
"assigned_to": self.filter_queryset(queryset, filter_backends=assigned_to_filter_backends),
"owners": self.filter_queryset(queryset, filter_backends=owners_filter_backends),
"priorities": self.filter_queryset(queryset, filter_backends=priorities_filter_backends),
"severities": self.filter_queryset(queryset, filter_backends=severities_filter_backends),
"tags": self.filter_queryset(queryset),
"roles": self.filter_queryset(queryset, filter_backends=roles_filter_backends),
}
return response.Ok(services.get_issues_filters_data(project, querysets))
def upvote(self, request, pk=None):
issue = get_object_or_404(models.Issue, pk=pk)
self.check_permissions(request, 'upvote', issue)
votes_service.add_vote(issue, user=request.user)
return Response(status=status.HTTP_200_OK)
def pre_delete(self, obj):
move_to = self.request.QUERY_PARAMS.get('moveTo', None)
if move_to:
role_dest = get_object_or_404(self.model, project=obj.project, id=move_to)
qs = models.Membership.objects.filter(project_id=obj.project.pk, role=obj)
qs.update(role=role_dest)
super().pre_delete(obj)
def pre_delete(self, obj):
move_to = self.request.QUERY_PARAMS.get("moveTo", None)
if move_to:
membership_model = apps.get_model("projects", "Membership")
role_dest = get_object_or_404(self.model, project=obj.project, id=move_to)
qs = membership_model.objects.filter(project_id=obj.project.pk, role=obj)
qs.update(role=role_dest)
super().pre_delete(obj)
def patch(self, request, *args, **kwargs):
self.check_permissions(request)
resource_id = kwargs.get("resource_id", None)
resource = get_object_or_404(self.resource_model, pk=resource_id)
resource.read = timezone.now()
resource.save()
return response.Ok({})
def authorize_token(application_id:int, user:object, state:str) -> object:
ApplicationToken = apps.get_model("external_apps", "ApplicationToken")
Application = apps.get_model("external_apps", "Application")
application = get_object_or_404(Application, id=application_id)
token, _ = ApplicationToken.objects.get_or_create(user=user, application=application)
token.update_auth_code()
token.state = state
token.save()
return token
def create(self, request):
project_permission = models.ContribDropboxProjectPermission()
project_permission.project = get_object_or_404(Project, pk=request.DATA.get('project'))
project_permission.upload_issue_attachments = request.DATA.get('upload_issue_attachments')
project_permission.upload_userstory_attachments = request.DATA.get('upload_userstory_attachments')
project_permission.upload_task_attachments = request.DATA.get('upload_task_attachments')
project_permission.upload_wiki_attachments = request.DATA.get('upload_wiki_attachments')
project_permission.save()
serializer = serializers.ContribDropboxProjectPermissionSerializer(project_permission)
return response.Ok(data=serializer.data)
def move_issues_to_sprint(self, request, pk=None, **kwargs):
milestone = get_object_or_404(models.Milestone, pk=pk)
self.check_permissions(request, "move_related_items", milestone)
validator = IssuesUpdateMilestoneValidator(data=request.DATA)
if not validator.is_valid():
return response.BadRequest(validator.errors)
data = validator.data
project = get_object_or_404(Project, pk=data["project_id"])
milestone_result = get_object_or_404(models.Milestone, pk=data["milestone_id"])
if data["bulk_issues"]:
self.check_permissions(request, "move_issues_to_sprint", project)
services.update_issues_milestone_in_bulk(data["bulk_issues"], milestone_result)
services.snapshot_issues_in_bulk(data["bulk_issues"], request.user)
return response.NoContent()
def csv(self, request):
uuid = request.QUERY_PARAMS.get("uuid", None)
if uuid is None:
return response.NotFound()
project = get_object_or_404(Project, issues_csv_uuid=uuid)
queryset = project.issues.all().order_by("ref")
data = services.issues_to_csv(project, queryset)
csv_response = HttpResponse(data.getvalue(), content_type="application/csv; charset=utf-8")
csv_response["Content-Disposition"] = 'attachment; filename="issues.csv"'
return csv_response
def list(self, request, **kwargs):
validator = ResolverValidator(data=request.QUERY_PARAMS)
if not validator.is_valid():
raise exc.BadRequest(validator.errors)
data = validator.data
project_model = apps.get_model("projects", "Project")
project = get_object_or_404(project_model, slug=data["project"])
self.check_permissions(request, "list", project)
result = {"project": project.pk}
if data["epic"] and user_has_perm(request.user, "view_epics", project):
result["epic"] = get_object_or_404(project.epics.all(),
ref=data["epic"]).pk
if data["us"] and user_has_perm(request.user, "view_us", project):
result["us"] = get_object_or_404(project.user_stories.all(),
ref=data["us"]).pk
if data["task"] and user_has_perm(request.user, "view_tasks", project):
result["task"] = get_object_or_404(project.tasks.all(),
ref=data["task"]).pk
if data["issue"] and user_has_perm(request.user, "view_issues", project):
result["issue"] = get_object_or_404(project.issues.all(),
ref=data["issue"]).pk
if data["milestone"] and user_has_perm(request.user, "view_milestones", project):
result["milestone"] = get_object_or_404(project.milestones.all(),
slug=data["milestone"]).pk
if data["wikipage"] and user_has_perm(request.user, "view_wiki_pages", project):
result["wikipage"] = get_object_or_404(project.wiki_pages.all(),
slug=data["wikipage"]).pk
if data["ref"]:
ref_found = False # No need to continue once one ref is found
if ref_found is False and user_has_perm(request.user, "view_epics", project):
epic = project.epics.filter(ref=data["ref"]).first()
if epic:
result["epic"] = epic.pk
ref_found = True
if user_has_perm(request.user, "view_us", project):
us = project.user_stories.filter(ref=data["ref"]).first()
if us:
result["us"] = us.pk
ref_found = True
if ref_found is False and user_has_perm(request.user, "view_tasks", project):
task = project.tasks.filter(ref=data["ref"]).first()
if task:
result["task"] = task.pk
ref_found = True
if ref_found is False and user_has_perm(request.user, "view_issues", project):
issue = project.issues.filter(ref=data["ref"]).first()
if issue:
result["issue"] = issue.pk
return response.Ok(result)
def remove_logo(self, request, *args, **kwargs):
"""
Remove the logo of a project.
"""
self.object = get_object_or_404(self.get_queryset(), **kwargs)
self.check_permissions(request, "remove_logo", self.object)
self.pre_conditions_on_save(self.object)
self.object.logo = None
self.object.save(update_fields=["logo"])
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def list(self, request, **kwargs):
serializer = ResolverSerializer(data=request.QUERY_PARAMS)
if not serializer.is_valid():
raise exc.BadRequest(serializer.errors)
data = serializer.data
project_model = apps.get_model("projects", "Project")
project = get_object_or_404(project_model, slug=data["project"])
self.check_permissions(request, "list", project)
result = {"project": project.pk}
if data["us"] and user_has_perm(request.user, "view_us", project):
result["us"] = get_object_or_404(project.user_stories.all(),
ref=data["us"]).pk
if data["task"] and user_has_perm(request.user, "view_tasks", project):
result["task"] = get_object_or_404(project.tasks.all(),
ref=data["task"]).pk
if data["issue"] and user_has_perm(request.user, "view_issues", project):
result["issue"] = get_object_or_404(project.issues.all(),
ref=data["issue"]).pk
if data["milestone"] and user_has_perm(request.user, "view_milestones", project):
result["milestone"] = get_object_or_404(project.milestones.all(),
slug=data["milestone"]).pk
if data["wikipage"] and user_has_perm(request.user, "view_wiki_pages", project):
result["wikipage"] = get_object_or_404(project.wiki_pages.all(),
slug=data["wikipage"]).pk
return response.Ok(result)
def _bulk_update_order(self, order_field, request, **kwargs):
serializer = serializers.UpdateTasksOrderBulkSerializer(data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = get_object_or_404(Project, pk=data["project_id"])
self.check_permissions(request, "bulk_update_order", project)
services.update_tasks_order_in_bulk(data["bulk_tasks"], project=project, field=order_field)
services.snapshot_tasks_in_bulk(data["bulk_tasks"], request.user)
return response.NoContent()
def filters_data(self, request, *args, **kwargs):
project_id = request.QUERY_PARAMS.get("project", None)
project = get_object_or_404(Project, id=project_id)
filter_backends = self.get_filter_backends()
owners_filter_backends = (f for f in filter_backends if f != filters.OwnersFilter)
tags_filter_backends = (f for f in filter_backends if f != filters.TagsFilter)
queryset = self.get_queryset()
querysets = {
"owners": self.filter_queryset(queryset, filter_backends=owners_filter_backends),
"tags": self.filter_queryset(queryset)
}
return response.Ok(services.get_product_increment_filters_data(project, querysets))
def get_serializer_class(self):
project_id = self.request.QUERY_PARAMS.get("project", None)
if project_id is None:
# Creation
if self.request.method == 'POST':
return self.admin_serializer_class
return self.serializer_class
project = get_object_or_404(models.Project, pk=project_id)
if permissions_service.is_project_owner(self.request.user, project):
return self.admin_serializer_class
return self.serializer_class
def validate(self, request, pk=None):
application_id = request.DATA.get("application", None)
auth_code = request.DATA.get("auth_code", None)
state = request.DATA.get("state", None)
application_token = get_object_or_404(models.ApplicationToken,
application__id=application_id,
auth_code=auth_code,
state=state)
application_token.generate_token()
application_token.save()
access_token_data = serializers.AccessTokenSerializer(application_token).data
return response.Ok(access_token_data)
def validate(self, data):
"""
All the userstories and the milestone are from the same project
"""
user_story_ids = [us["us_id"] for us in data["bulk_stories"]]
project = get_object_or_404(Project, pk=data["project_id"])
if project.user_stories.filter(id__in=user_story_ids).count() != len(user_story_ids):
raise ValidationError("all the user stories must be from the same project")
if project.milestones.filter(id=data["milestone_id"]).count() != 1:
raise ValidationError("the milestone isn't valid for the project")
return data
def retrieve(self, request, *args, **kwargs):
pk = kwargs.get("pk", None)
resource_id = kwargs.get("resource_id", None)
resource = get_object_or_404(self.resource_model, pk=resource_id)
self.check_permissions(request, 'retrieve', resource)
try:
self.object = resource.get_watchers().get(pk=pk)
except ObjectDoesNotExist: # or User.DoesNotExist
return response.NotFound()
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def _bulk_update_order(self, order_field, request, **kwargs):
serializer = serializers.UpdateUserStoriesOrderBulkSerializer(
data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = get_object_or_404(Project, pk=data["project_id"])
self.check_permissions(request, "bulk_update_order", project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
services.update_userstories_order_in_bulk(data["bulk_stories"],
project=project,
field=order_field)
services.snapshot_userstories_in_bulk(data["bulk_stories"],
request.user)
return response.NoContent()
def token(self, request, *args, **kwargs):
if self.request.user.is_anonymous():
raise exc.NotAuthenticated(_("Authentication required"))
application = get_object_or_404(models.Application, **kwargs)
self.check_permissions(request, 'token', request.user)
try:
application_token = models.ApplicationToken.objects.get(user=request.user, application=application)
application_token.update_auth_code()
application_token.state = request.GET.get("state", None)
application_token.save()
except models.ApplicationToken.DoesNotExist:
application_token = models.ApplicationToken(
user=request.user,
application=application
)
auth_code_data = serializers.ApplicationTokenSerializer(application_token).data
return response.Ok(auth_code_data)
def retrieve(self, request, *args, **kwargs):
qs = self.get_queryset()
if self.action == "by_slug":
self.lookup_field = "slug"
# If we retrieve the project by slug we want to filter by user the
# permissions and return 404 in case the user don't have access
flt = filters.get_filter_expression_can_view_projects(
self.request.user)
qs = qs.filter(flt)
self.object = get_object_or_404(qs, **kwargs)
self.check_permissions(request, 'retrieve', self.object)
if self.object is None:
raise Http404
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def watched(self, request, *args, **kwargs):
for_user = get_object_or_404(models.User, **kwargs)
from_user = request.user
self.check_permissions(request, 'watched', for_user)
filters = {
"type": request.GET.get("type", None),
"q": request.GET.get("q", None),
}
self.object_list = services.get_watched_list(for_user, from_user, **filters)
page = self.paginate_queryset(self.object_list)
elements = page.object_list if page is not None else self.object_list
extra_args = {
"user_votes": services.get_voted_content_for_user(request.user),
"user_watching": services.get_watched_content_for_user(request.user),
}
response_data = [self._serialize_liked_content(elem, **extra_args).data for elem in elements]
return response.Ok(response_data)
def filters_data(self, request, *args, **kwargs):
project_id = request.QUERY_PARAMS.get("project", None)
project = get_object_or_404(Project, id=project_id)
filter_backends = self.get_filter_backends()
statuses_filter_backends = (f for f in filter_backends if f != filters.StatusesFilter)
assigned_to_filter_backends = (f for f in filter_backends if f != filters.AssignedToFilter)
owners_filter_backends = (f for f in filter_backends if f != filters.OwnersFilter)
roles_filter_backends = (f for f in filter_backends if f != filters.RoleFilter)
tags_filter_backends = (f for f in filter_backends if f != filters.TagsFilter)
queryset = self.get_queryset()
querysets = {
"statuses": self.filter_queryset(queryset, filter_backends=statuses_filter_backends),
"assigned_to": self.filter_queryset(queryset, filter_backends=assigned_to_filter_backends),
"owners": self.filter_queryset(queryset, filter_backends=owners_filter_backends),
"tags": self.filter_queryset(queryset, filter_backends=tags_filter_backends),
"roles": self.filter_queryset(queryset, filter_backends=roles_filter_backends),
}
return response.Ok(services.get_tasks_filters_data(project, querysets))
def bulk_update_order(self, request, **kwargs):
bulk_data = request.DATA.get(self.bulk_update_param, None)
if bulk_data is None:
raise exc.BadRequest(
_("'{param}' parameter is mandatory".format(
param=self.bulk_update_param)))
project_id = request.DATA.get("project", None)
if project_id is None:
raise exc.BadRequest(_("'project' parameter is mandatory"))
project = get_object_or_404(Project, id=project_id)
self.check_permissions(request, "bulk_update_order", project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
self.__class__.bulk_update_order_action(project, request.user,
bulk_data)
return response.NoContent(data=None)
def destroy(self, request, *args, **kwargs):
move_to = self.request.QUERY_PARAMS.get('moveTo', None)
if move_to is None:
return super().destroy(request, *args, **kwargs)
obj = self.get_object_or_none()
move_item = get_object_or_404(self.model, id=move_to)
self.check_permissions(request, 'destroy', obj)
qs = self.move_on_destroy_related_class.objects.filter(
**{self.move_on_destroy_related_field: obj})
qs.update(**{self.move_on_destroy_related_field: move_item})
if getattr(obj.project,
self.move_on_destroy_project_default_field) == obj:
setattr(obj.project, self.move_on_destroy_project_default_field,
move_item)
obj.project.save()
return super().destroy(request, *args, **kwargs)
def list(self, request, **kwargs):
serializer = ResolverSerializer(data=request.QUERY_PARAMS)
if not serializer.is_valid():
raise exc.BadRequest(serializer.errors)
data = serializer.data
project_model = apps.get_model("projects", "Project")
project = get_object_or_404(project_model, slug=data["project"])
self.check_permissions(request, "list", project)
result = {"project": project.pk}
if data["us"] and user_has_perm(request.user, "view_us", project):
result["us"] = get_object_or_404(project.user_stories.all(),
ref=data["us"]).pk
if data["task"] and user_has_perm(request.user, "view_tasks", project):
result["task"] = get_object_or_404(project.tasks.all(),
ref=data["task"]).pk
if data["issue"] and user_has_perm(request.user, "view_issues", project):
result["issue"] = get_object_or_404(project.issues.all(),
ref=data["issue"]).pk
if data["milestone"] and user_has_perm(request.user, "view_milestones", project):
result["milestone"] = get_object_or_404(project.milestones.all(),
slug=data["milestone"]).pk
if data["wikipage"] and user_has_perm(request.user, "view_wiki_pages", project):
result["wikipage"] = get_object_or_404(project.wiki_pages.all(),
slug=data["wikipage"]).pk
if data["ref"]:
ref_found = False # No need to continue once one ref is found
if user_has_perm(request.user, "view_us", project):
us = project.user_stories.filter(ref=data["ref"]).first()
if us:
result["us"] = us.pk
ref_found = True
if ref_found is False and user_has_perm(request.user, "view_tasks", project):
task = project.tasks.filter(ref=data["ref"]).first()
if task:
result["task"] = task.pk
ref_found = True
if ref_found is False and user_has_perm(request.user, "view_issues", project):
issue = project.issues.filter(ref=data["ref"]).first()
if issue:
result["issue"] = issue.pk
return response.Ok(result)
def get_serializer_class(self):
use_admin_serializer = False
if self.action == "create":
use_admin_serializer = True
if self.action == "retrieve":
use_admin_serializer = permissions_services.is_project_admin(
self.request.user, self.object.project)
project_id = self.request.QUERY_PARAMS.get("project", None)
if self.action == "list" and project_id is not None:
project = get_object_or_404(models.Project, pk=project_id)
use_admin_serializer = permissions_services.is_project_admin(
self.request.user, project)
if use_admin_serializer:
return self.admin_serializer_class
else:
return self.serializer_class
def watched(self, request, *args, **kwargs):
for_user = get_object_or_404(models.User, **kwargs)
from_user = request.user
self.check_permissions(request, 'watched', for_user)
filters = {
"type": request.GET.get("type", None),
"q": request.GET.get("q", None),
}
self.object_list = services.get_watched_list(for_user, from_user,
**filters)
page = self.paginate_queryset(self.object_list)
elements = page.object_list if page is not None else self.object_list
extra_args_liked = {
"user_watching":
services.get_watched_content_for_user(request.user),
"user_likes": services.get_liked_content_for_user(request.user),
}
extra_args_voted = {
"user_watching":
services.get_watched_content_for_user(request.user),
"user_votes": services.get_voted_content_for_user(request.user),
}
response_data = []
for elem in elements:
if elem["type"] == "project":
# projects are liked objects
response_data.append(
serializers.LikedObjectSerializer(elem,
**extra_args_liked).data)
else:
# stories, tasks and issues are voted objects
response_data.append(
serializers.VotedObjectSerializer(elem,
**extra_args_voted).data)
return response.Ok(response_data)
def duplicate_project(project, **new_project_extra_args):
owner = new_project_extra_args.get("owner")
users = new_project_extra_args.pop("users")
disconnect_projects_signals()
Project = apps.get_model("projects", "Project")
new_project = Project.objects.create(**new_project_extra_args)
connect_projects_signals()
permissions_services.set_base_permissions_for_project(new_project)
# Cloning the structure from the old project using templates
Template = apps.get_model("projects", "ProjectTemplate")
template = Template()
template.load_data_from_project(project)
template.apply_to_project(new_project)
new_project.creation_template = project.creation_template
new_project.save()
# Creating the membership for the new owner
Membership = apps.get_model("projects", "Membership")
Membership.objects.create(
user=owner,
is_admin=True,
role=new_project.roles.get(slug=template.default_owner_role),
project=new_project)
# Creating the extra memberships
for user in users:
project_memberships = project.memberships.exclude(user_id=owner.id)
membership = get_object_or_404(project_memberships, user_id=user["id"])
Membership.objects.create(
user=membership.user,
is_admin=membership.is_admin,
role=new_project.roles.get(slug=membership.role.slug),
project=new_project)
# Take initial snapshot for the project
take_snapshot(new_project, user=owner)
return new_project
def _bulk_update_order(self, order_field, request, **kwargs):
serializer = serializers.UpdateUserStoriesOrderBulkSerializer(data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = get_object_or_404(Project, pk=data["project_id"])
self.check_permissions(request, "bulk_update_order", project)
services.update_userstories_order_in_bulk(data["bulk_stories"],
project=project,
field=order_field)
services.snapshot_userstories_in_bulk(data["bulk_stories"], request.user)
if order_field in ["sprint_order", "backlog_order"]:
# NOTE: This is useful according to issue #2851 to update sprints column in
# the browser client when move USs from the backlog to an sprint, from
# an sprint to the backlog or between sprints.
has_closed_milestones = project.milestones.filter(closed=True).exists()
self.headers["Taiga-Info-Has-Closed-Milestones"] = has_closed_milestones
return response.NoContent()
def change_logo(self, request, *args, **kwargs):
"""
Change logo to this project.
"""
self.object = get_object_or_404(self.get_queryset(), **kwargs)
self.check_permissions(request, "change_logo", self.object)
logo = request.FILES.get('logo', None)
if not logo:
raise exc.WrongArguments(_("Incomplete arguments"))
try:
pil_image(logo)
except Exception:
raise exc.WrongArguments(_("Invalid image format"))
self.pre_conditions_on_save(self.object)
self.object.logo = logo
self.object.save(update_fields=["logo"])
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def stats(self, request, pk=None):
milestone = get_object_or_404(models.Milestone, pk=pk)
self.check_permissions(request, "stats", milestone)
total_points = milestone.total_points
milestone_stats = {
'name': milestone.name,
'estimated_start': milestone.estimated_start,
'estimated_finish': milestone.estimated_finish,
'total_points': total_points,
'completed_points': milestone.closed_points.values(),
'total_userstories': milestone.cached_user_stories.count(),
'completed_userstories': milestone.cached_user_stories.filter(is_closed=True).count(),
'total_tasks': milestone.tasks.count(),
'completed_tasks': milestone.tasks.filter(status__is_closed=True).count(),
'iocaine_doses': milestone.tasks.filter(is_iocaine=True).count(),
'days': []
}
current_date = milestone.estimated_start
sumTotalPoints = sum(total_points.values())
optimal_points = sumTotalPoints
milestone_days = self.count_weekdays(milestone.estimated_start, milestone.estimated_finish)
optimal_points_per_day = sumTotalPoints / milestone_days if milestone_days else 0
while current_date <= milestone.estimated_finish:
if self.is_weekday(current_date):
optimal_points -= optimal_points_per_day
milestone_stats['days'].append({
'day': current_date,
'name': current_date.day,
'open_points': sumTotalPoints - milestone.total_closed_points_by_date(current_date),
'optimal_points': optimal_points,
})
current_date = current_date + datetime.timedelta(days=1)
return response.Ok(milestone_stats)
def retrieve(self, request, pk, *args, **kwargs):
throttle = throttling.ImportDumpModeRateThrottle()
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait())
project = get_object_or_404(self.get_queryset(), pk=pk)
self.check_permissions(request, 'export_project', project)
if settings.CELERY_ENABLED:
task = tasks.dump_project.delay(request.user, project)
tasks.delete_project_dump.apply_async(
(project.pk, project.slug), countdown=settings.EXPORTS_TTL)
return response.Accepted({"export_id": task.id})
path = "exports/{}/{}-{}.json".format(project.pk, project.slug,
uuid.uuid4().hex)
storage_path = default_storage.path(path)
with default_storage.open(storage_path, mode="w") as outfile:
service.render_project(project, outfile)
response_data = {"url": default_storage.url(path)}
return response.Ok(response_data)
def destroy(self, request, *args, **kwargs):
obj = self.get_object_or_none()
self.check_permissions(request, 'destroy', obj)
move_to = self.request.QUERY_PARAMS.get('moveTo', None)
if move_to is None:
total_elements = obj.project.swimlanes.count()
# you cannot set swimlane=None if there are more swimlanes available
if total_elements > 1:
raise exc.BadRequest(_("Cannot set swimlane to None if there are available swimlanes"))
# but if it was the last swimlane,
# it can be deleted and all uss have now swimlane=None
obj.user_stories.update(swimlane_id=None)
else:
move_item = get_object_or_404(self.model, id=move_to)
# check permisions over moveTo object
self.check_permissions(request, 'destroy', move_item)
update_order_and_swimlane(obj, move_item)
return super().destroy(request, *args, **kwargs)
def filters_data(self, request, *args, **kwargs):
project_id = request.QUERY_PARAMS.get("project", None)
project = get_object_or_404(Project, id=project_id)
filter_backends = self.get_filter_backends()
types_filter_backends = (f for f in filter_backends if f != filters.IssueTypesFilter)
statuses_filter_backends = (f for f in filter_backends if f != filters.StatusesFilter)
assigned_to_filter_backends = (f for f in filter_backends if f != filters.AssignedToFilter)
owners_filter_backends = (f for f in filter_backends if f != filters.OwnersFilter)
priorities_filter_backends = (f for f in filter_backends if f != filters.PrioritiesFilter)
severities_filter_backends = (f for f in filter_backends if f != filters.SeveritiesFilter)
queryset = self.get_queryset()
querysets = {
"types": self.filter_queryset(queryset, filter_backends=types_filter_backends),
"statuses": self.filter_queryset(queryset, filter_backends=statuses_filter_backends),
"assigned_to": self.filter_queryset(queryset, filter_backends=assigned_to_filter_backends),
"owners": self.filter_queryset(queryset, filter_backends=owners_filter_backends),
"priorities": self.filter_queryset(queryset, filter_backends=priorities_filter_backends),
"severities": self.filter_queryset(queryset, filter_backends=severities_filter_backends),
"tags": self.filter_queryset(queryset)
}
return response.Ok(services.get_issues_filters_data(project, querysets))
def retrieve(self, request, pk, *args, **kwargs):
throttle = throttling.ImportDumpModeRateThrottle()
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait())
project = get_object_or_404(self.get_queryset(), pk=pk)
self.check_permissions(request, 'export_project', project)
if settings.CELERY_ENABLED:
task = tasks.dump_project.delay(request.user, project)
tasks.delete_project_dump.apply_async((project.pk, project.slug),
countdown=settings.EXPORTS_TTL)
return response.Accepted({"export_id": task.id})
path = "exports/{}/{}-{}.json".format(project.pk, project.slug, uuid.uuid4().hex)
content = ContentFile(ExportRenderer().render(service.project_to_dict(project),
renderer_context={"indent": 4}).decode('utf-8'))
default_storage.save(path, content)
response_data = {
"url": default_storage.url(path)
}
return response.Ok(response_data)
def retrieve(self, request, *args, **kwargs):
self.object = get_object_or_404(models.User, **kwargs)
self.check_permissions(request, 'retrieve', self.object)
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def get_content_type(self):
app_name, model = self.content_type.split(".", 1)
return get_object_or_404(ContentType, app_label=app_name, model=model)
def by_ref(self, request):
ref = request.QUERY_PARAMS.get("ref", None)
project_id = request.QUERY_PARAMS.get("project", None)
task = get_object_or_404(models.Task, ref=ref, project_id=project_id)
return self.retrieve(request, pk=task.pk)
def list(self, request, *args, **kwargs):
issue_id = kwargs.get("issue_id", None)
issue = get_object_or_404(models.Issue, pk=issue_id)
self.check_permissions(request, 'list', issue)
return super().list(request, *args, **kwargs)
def stats(self, request, pk=None):
milestone = get_object_or_404(models.Milestone, pk=pk)
self.check_permissions(request, "stats", milestone)
total_points = milestone.total_points
milestone_stats = {
'name':
milestone.name,
'estimated_start':
milestone.estimated_start,
'estimated_finish':
milestone.estimated_finish,
'total_points':
total_points,
'completed_points':
milestone.closed_points.values(),
'total_userstories':
milestone.cached_user_stories.count(),
'completed_userstories':
milestone.cached_user_stories.filter(is_closed=True).count(),
'total_tasks':
milestone.tasks.count(),
'completed_tasks':
milestone.tasks.filter(status__is_closed=True).count(),
'iocaine_doses':
milestone.tasks.filter(is_iocaine=True).count(),
'days': []
}
current_date = milestone.estimated_start
sumTotalPoints = sum(total_points.values())
optimal_points = sumTotalPoints
milestone_days = (milestone.estimated_finish -
milestone.estimated_start).days
optimal_points_per_day = sumTotalPoints / milestone_days if milestone_days else 0
while current_date <= milestone.estimated_finish:
milestone_stats['days'].append({
'day':
current_date,
'name':
current_date.day,
'open_points':
sumTotalPoints -
milestone.total_closed_points_by_date(current_date),
'optimal_points':
optimal_points,
})
current_date = current_date + datetime.timedelta(days=1)
optimal_points -= optimal_points_per_day
# x = []
# y = []
# optimal = []
# for day in milestone_stats['days']:
# x.append(day['day'])
# y.append(day['open_points'])
# optimal.append(day['optimal_points'])
# print('x = numpy.array(' + str(x) + ')')
# print('y = numpy.array(' + str(y) + ')')
# print('optimal = numpy.array(' + str(optimal) + ')')
return response.Ok(milestone_stats)
def _get_project(self, project_id):
project_model = apps.get_model("projects", "Project")
return get_object_or_404(project_model, pk=project_id)
def by_slug(self, request):
slug = request.QUERY_PARAMS.get("slug", None)
project_id = request.QUERY_PARAMS.get("project", None)
wiki_page = get_object_or_404(models.WikiPage, slug=slug, project_id=project_id)
return self.retrieve(request, pk=wiki_page.pk)
def by_slug(self, request):
slug = request.QUERY_PARAMS.get("slug", None)
project = get_object_or_404(models.Project, slug=slug)
return self.retrieve(request, pk=project.pk)
def csv(self, request):
get_data = {}
status_id = []
# PDF or Excel
doc_type = request.QUERY_PARAMS.get('doc_type', None)
uuid = request.QUERY_PARAMS.get("uuid", None)
start_date = request.QUERY_PARAMS.get('start_date', None)
end_date = request.QUERY_PARAMS.get('end_date', None)
type = request.QUERY_PARAMS.get('type', None)
status = request.QUERY_PARAMS.get('status', None)
asset = request.QUERY_PARAMS.get('asset_cat', None)
performance = request.QUERY_PARAMS.get('performance_cat', None)
photo = request.QUERY_PARAMS.get('photo', None)
name = request.QUERY_PARAMS.get('type_name', None)
accident_report_type = request.QUERY_PARAMS.get(
'accident_report_type', None)
if status:
status = status.split(',')
if uuid is None:
return response.NotFound()
project = get_object_or_404(Project, issues_csv_uuid=uuid)
if asset and performance:
if status:
queryset = project.issues.filter(issue_category=asset,
issue_subcategory=performance,
type__name=type,
status__id__in=status,
created_date__date__range=[
start_date, end_date
]).order_by('-created_date')
else:
if type == "Investigation":
queryset = project.issues.filter(
asset_name=asset,
test_name=performance,
type__name=type,
created_date__date__range=[start_date, end_date
]).order_by('-created_date')
else:
queryset = project.issues.filter(
issue_category=asset,
issue_subcategory=performance,
type__name=type,
created_date__date__range=[start_date, end_date
]).order_by('-created_date')
elif asset and not performance:
if status:
queryset = project.issues.filter(issue_category=asset,
type__name=type,
status__id__in=status,
created_date__date__range=[
start_date, end_date
]).order_by('-created_date')
else:
if type == "Investigation":
queryset = project.issues.filter(
asset_name=asset,
type__name=type,
created_date__date__range=[start_date, end_date
]).order_by('-created_date')
else:
queryset = project.issues.filter(
issue_category=asset,
type__name=type,
created_date__date__range=[start_date, end_date
]).order_by('-created_date')
else:
queryset = project.issues.filter(
type__name=type,
created_date__date__range=[start_date,
end_date]).order_by('-created_date')
data = write_excel.write_excel(self, request, project, queryset, type,
status, start_date, end_date, asset,
performance, photo, doc_type, name,
accident_report_type)
if doc_type == "excel":
csv_response = HttpResponse(
save_virtual_workbook(data),
content_type='application/vnd.ms-excel; charset=utf-8')
csv_response[
'Content-Disposition'] = 'attachment; filename="issues.xlsx"'
return csv_response
if doc_type == "pdf":
html = HTML(string=data)
html.write_pdf(
target='/tmp/mypdf.pdf',
stylesheets=[CSS(settings.STATIC_ROOT + '/main.css')],
presentational_hints=True)
# print("=============================")
# print(html)
fs = FileSystemStorage('/tmp')
with fs.open('mypdf.pdf') as pdf:
response = HttpResponse(pdf, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename="mypdf.pdf"'
return response
def by_ref(self, request):
ref = request.QUERY_PARAMS.get("ref", None)
project_id = request.QUERY_PARAMS.get("project", None)
issue = get_object_or_404(models.Issue, ref=ref, project_id=project_id)
return self.retrieve(request, pk=issue.pk)
def stats(self, request, *args, **kwargs):
user = get_object_or_404(models.User, **kwargs)
self.check_permissions(request, "stats", user)
return response.Ok(services.get_stats_for_user(user, request.user))
def by_ref(self, request):
ref = request.QUERY_PARAMS.get("ref", None)
project_id = request.QUERY_PARAMS.get("project", None)
userstory = get_object_or_404(models.UserStory, ref=ref, project_id=project_id)
return self.retrieve(request, pk=userstory.pk)
