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)