def leave(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "leave", project)
self.pre_conditions_on_save(project)
services.remove_user_from_project(request.user, project)
return response.Ok()
def list(self, request, **kwargs):
stats = OrderedDict()
stats["projects"] = services.get_projects_discover_stats(
user=request.user)
return response.Ok(stats)
def regenerate_tasks_csv_uuid(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "regenerate_tasks_csv_uuid", project)
data = {"uuid": self._regenerate_csv_uuid(project, "tasks_csv_uuid")}
return response.Ok(data)
def member_stats(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "member_stats", project)
return response.Ok(data=services.get_member_stats_for_project(project))
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 issue_filters_data(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "issues_filters_data", project)
return response.Ok(data=services.get_issues_filters_data(project))
def unstar(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "unstar", project)
votes_service.remove_vote(project, user=request.user)
return response.Ok()
def _add_voter(self, permission, request, pk=None):
obj = self.get_object()
self.check_permissions(request, permission, obj)
services.add_vote(obj, user=request.user)
return response.Ok()
def downvote(self, request, pk=None):
obj = self.get_object()
self.check_permissions(request, "downvote", obj)
services.remove_vote(obj, user=request.user)
return response.Ok()
def like(self, request, pk=None):
obj = self.get_object()
self.check_permissions(request, "like", obj)
services.add_like(obj, user=request.user)
return response.Ok()
def import_project(self, request, *args, **kwargs):
self.check_permissions(request, "import_project", None)
url = request.DATA.get('url', None)
token = self._get_token(request)
project_id = request.DATA.get('project', None)
if not project_id:
raise exc.WrongArguments(_("The project param is needed"))
if not url:
raise exc.WrongArguments(_("The url param is needed"))
options = {
"name":
request.DATA.get('name', None),
"description":
request.DATA.get('description', None),
"users_bindings":
resolve_users_bindings(request.DATA.get("users_bindings", {})),
"keep_external_reference":
request.DATA.get("keep_external_reference", False),
"is_private":
request.DATA.get("is_private", False),
}
importer_type = request.DATA.get('importer_type', "normal")
if importer_type == "agile":
importer = JiraAgileImporter(request.user, url, token)
else:
project_type = request.DATA.get("project_type", "scrum")
if project_type == "kanban":
options['template'] = "kanban"
else:
options['template'] = "scrum"
importer = JiraNormalImporter(request.user, url, token)
types_bindings = {
"epic": [],
"us": [],
"task": [],
"issue": [],
}
for issue_type in importer.list_issue_types(project_id):
if project_type in ['scrum', 'kanban']:
# Set the type bindings
if issue_type['subtask']:
types_bindings['task'].append(issue_type)
elif issue_type['name'].upper() == "EPIC":
types_bindings["epic"].append(issue_type)
elif issue_type['name'].upper() in [
"US", "USERSTORY", "USER STORY"
]:
types_bindings["us"].append(issue_type)
elif issue_type['name'].upper() in [
"ISSUE", "BUG", "ENHANCEMENT"
]:
types_bindings["issue"].append(issue_type)
else:
types_bindings["us"].append(issue_type)
elif project_type == "issues":
# Set the type bindings
if issue_type['subtask']:
continue
types_bindings["issue"].append(issue_type)
elif project_type == "issues-with-subissues":
types_bindings["issue"].append(issue_type)
else:
raise exc.WrongArguments(
_("Invalid project_type {}").format(project_type))
options["types_bindings"] = types_bindings
if settings.CELERY_ENABLED:
task = tasks.import_project.delay(request.user.id, url, token,
project_id, options,
importer_type)
return response.Accepted({"task_id": task.id})
project = importer.import_project(project_id, options)
project_data = {
"slug": project.slug,
"my_permissions": ["view_us"],
"is_backlog_activated": project.is_backlog_activated,
"is_kanban_activated": project.is_kanban_activated,
}
return response.Ok(project_data)
def watch(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "watch", project)
notify_level = request.DATA.get("notify_level", NotifyLevel.involved)
project.add_watcher(self.request.user, notify_level=notify_level)
return response.Ok()
def retrieve(self, request, pk=None):
wiki_pages = models.WikiPage.objects.filter(owner_id=pk)
serializer = serializers.WikiPageSerializer(wiki_pages, many=True)
print(serializer.data)
return response.Ok(serializer.data)
def retrieve(self, request, *args, **kwargs):
self.object = get_object_or_404(self.get_queryset(), **kwargs)
self.check_permissions(request, "retrieve", self.object)
serializer = self.get_serializer(self.object)
return response.Ok(serializer.data)
def delete_issues_csv_uuid(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "delete_issues_csv_uuid", project)
self.pre_conditions_on_save(project)
data = {"uuid": self._delete_csv_uuid(project, "issues_csv_uuid")}
return response.Ok(data)
def watch(self, request, pk=None):
obj = self.get_object()
self.check_permissions(request, "watch", obj)
services.add_watcher(obj, request.user)
return response.Ok()
def transfer_request(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "transfer_request", project)
services.request_project_transfer(project, request.user)
return response.Ok()
def list_projects(self, request, *args, **kwargs):
self.check_permissions(request, "list_projects", None)
token = request.DATA.get('token', None)
importer = GithubImporter(request.user, token)
projects = importer.list_projects()
return response.Ok(projects)
def tags_colors(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "tags_colors", project)
return response.Ok(data=dict(project.tags_colors))
def unwatch(self, request, pk=None):
obj = self.get_object()
self.check_permissions(request, "unwatch", obj)
self.pre_conditions_on_save(obj)
services.remove_watcher(obj, request.user)
return response.Ok()
def leave(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, 'leave', project)
services.remove_user_from_project(request.user, project)
return response.Ok()
def retrieve(self, request, pk=None):
project_details = models.Membership.objects.filter(project_id=pk)
serializer = serializers.MembershipSerializer(project_details,
many=True)
return response.Ok(serializer.data)
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 transfer_validate_token(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "transfer_validate_token", project)
token = request.DATA.get('token', None)
services.transfer.validate_project_transfer_token(token, project, request.user)
return response.Ok()
def list(self, request, **kwargs):
stats = OrderedDict()
stats["users"] = services.get_users_public_stats()
stats["projects"] = services.get_projects_public_stats()
stats["userstories"] = services.get_user_stories_public_stats()
return response.Ok(stats)
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
try:
value = int(data["ref"])
if user_has_perm(request.user, "view_epics", project):
epic = project.epics.filter(ref=value).first()
if epic:
result["epic"] = epic.pk
ref_found = True
if ref_found is False and user_has_perm(
request.user, "view_us", project):
us = project.user_stories.filter(ref=value).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=value).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=value).first()
if issue:
result["issue"] = issue.pk
except:
value = data["ref"]
if user_has_perm(request.user, "view_wiki_pages", project):
wiki_page = project.wiki_pages.filter(slug=value).first()
if wiki_page:
result["wikipage"] = wiki_page.pk
return response.Ok(result)
def unwatch(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "unwatch", project)
user = self.request.user
project.remove_watcher(user)
return response.Ok()
def regenerate_epics_csv_uuid(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "regenerate_epics_csv_uuid", project)
self.pre_conditions_on_save(project)
data = {"uuid": self._regenerate_csv_uuid(project, "epics_csv_uuid")}
return response.Ok(data)
def issues_stats(self, request, pk=None):
project = self.get_object()
self.check_permissions(request, "issues_stats", project)
return response.Ok(services.get_stats_for_project_issues(project))
def list(self, request):
self.check_permissions(request, "list", None)
queryset = models.FeedbackEntry.objects.filter(full_name=request.user)
serializer = serializers.FeedbackSerializer(queryset, many=True)
return response.Ok(serializer.data)
