def load_dump(self, request):
throttle = throttling.ImportDumpModeRateThrottle()
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait())
self.check_permissions(request, "load_dump", None)
dump = request.FILES.get('dump', None)
if not dump:
raise exc.WrongArguments(_("Needed dump file"))
reader = codecs.getreader("utf-8")
try:
dump = json.load(reader(dump))
is_private = dump.get("is_private", False)
except Exception:
raise exc.WrongArguments(_("Invalid dump format"))
user = request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
user,
project=Project(is_private=is_private, id=None)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
slug = dump.get('slug', None)
if slug is not None and Project.objects.filter(slug=slug).exists():
del dump['slug']
members = len(dump.get("memberships", []))
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
user,
project=Project(is_private=is_private, id=None),
members=max(members, 1)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if settings.CELERY_ENABLED:
task = tasks.load_project_dump.delay(user, dump)
return response.Accepted({"import_id": task.id})
project = dump_service.dict_to_project(dump, request.user)
response_data = ProjectSerializer(project).data
return response.Created(response_data)
def load_dump(self, request):
throttle = throttling.ImportDumpModeRateThrottle()
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait())
self.check_permissions(request, "load_dump", None)
dump = request.FILES.get('dump', None)
if not dump:
raise exc.WrongArguments(_("Needed dump file"))
reader = codecs.getreader("utf-8")
try:
dump = json.load(reader(dump))
is_private = dump.get("is_private", False)
except Exception:
raise exc.WrongArguments(_("Invalid dump format"))
user = request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
user,
project=Project(is_private=is_private, id=None)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if Project.objects.filter(slug=dump['slug']).exists():
del dump['slug']
members = len(dump.get("memberships", []))
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
user,
project=Project(is_private=is_private, id=None),
members=max(members, 1)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if settings.CELERY_ENABLED:
task = tasks.load_project_dump.delay(user, dump)
return response.Accepted({"import_id": task.id})
project = dump_service.dict_to_project(dump, request.user)
response_data = ProjectSerializer(project).data
return response.Created(response_data)
def bulk_create(self, request, **kwargs):
serializer = serializers.MembersBulkSerializer(data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = models.Project.objects.get(id=data["project_id"])
invitation_extra_text = data.get("invitation_extra_text", None)
self.check_permissions(request, 'bulk_create', project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
# TODO: this should be moved to main exception handler instead
# of handling explicit exception catchin here.
if "bulk_memberships" in data and isinstance(data["bulk_memberships"], list):
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
request.user,
project=project,
members=len(data["bulk_memberships"])
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
try:
members = services.create_members_in_bulk(data["bulk_memberships"],
project=project,
invitation_extra_text=invitation_extra_text,
callback=self.post_save,
precall=self.pre_save)
except ValidationError as err:
return response.BadRequest(err.message_dict)
members_serialized = self.admin_serializer_class(members, many=True)
return response.Ok(members_serialized.data)
def bulk_create(self, request, **kwargs):
serializer = serializers.MembersBulkSerializer(data=request.DATA)
if not serializer.is_valid():
return response.BadRequest(serializer.errors)
data = serializer.data
project = models.Project.objects.get(id=data["project_id"])
invitation_extra_text = data.get("invitation_extra_text", None)
self.check_permissions(request, 'bulk_create', project)
if project.blocked_code is not None:
raise exc.Blocked(_("Blocked element"))
# TODO: this should be moved to main exception handler instead
# of handling explicit exception catchin here.
if "bulk_memberships" in data and isinstance(data["bulk_memberships"], list):
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
request.user,
project=project,
members=len(data["bulk_memberships"])
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
try:
members = services.create_members_in_bulk(data["bulk_memberships"],
project=project,
invitation_extra_text=invitation_extra_text,
callback=self.post_save,
precall=self.pre_save)
except ValidationError as err:
return response.BadRequest(err.message_dict)
members_serialized = self.admin_serializer_class(members, many=True)
return response.Ok(members_serialized.data)
def pre_save(self, obj):
user = self.request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(user, project=obj)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if not obj.id:
obj.owner = user
obj.template = self.request.QUERY_PARAMS.get('template', None)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
user = self.request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(user, project=obj)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if not obj.id:
obj.owner = user
obj.template = self.request.QUERY_PARAMS.get('template', None)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
user = self.request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(user, project=obj)
members = max(obj.memberships.count(), 1)
if not enough_slots:
raise exc.NotEnoughSlotsForProject(obj.is_private, members, not_enough_slots_error)
if not obj.id:
obj.owner = user
obj.template = self.request.QUERY_PARAMS.get('template', None)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
user = self.request.user
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(user, project=obj)
members = max(obj.memberships.count(), 1)
if not enough_slots:
raise exc.NotEnoughSlotsForProject(obj.is_private, members, not_enough_slots_error)
if not obj.id:
obj.owner = user
obj.template = self.request.QUERY_PARAMS.get('template', None)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
if not obj.id:
obj.owner = self.request.user
obj.template = self.request.QUERY_PARAMS.get('template', None)
# Validate if the owner have enought slots to create or update the project
# TODO: Move to the ProjectAdminSerializer
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(obj.owner, obj)
if not enough_slots:
members = max(obj.memberships.count(), 1)
raise exc.NotEnoughSlotsForProject(obj.is_private, members, not_enough_slots_error)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
if not obj.id:
(enough_slots, not_enough_slots_error
) = users_service.has_available_slot_for_project(
self.request.user, project=obj.project, members=1)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if not obj.token:
obj.token = str(uuid.uuid1())
obj.invited_by = self.request.user
obj.user = services.find_invited_user(obj.email, default=obj.user)
super().pre_save(obj)
def pre_save(self, obj):
if not obj.id:
obj.owner = self.request.user
obj.template = self.request.QUERY_PARAMS.get('template', None)
# Validate if the owner have enought slots to create or update the project
# TODO: Move to the ProjectAdminSerializer
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(obj.owner, obj)
if not enough_slots:
members = max(obj.memberships.count(), 1)
raise exc.NotEnoughSlotsForProject(obj.is_private, members, not_enough_slots_error)
self._set_base_permissions(obj)
super().pre_save(obj)
def pre_save(self, obj):
if not obj.id:
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
self.request.user,
project=obj.project,
members=1
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
if not obj.token:
obj.token = str(uuid.uuid1())
obj.invited_by = self.request.user
obj.user = services.find_invited_user(obj.email, default=obj.user)
super().pre_save(obj)
def transfer_accept(self, request, pk=None):
token = request.DATA.get('token', None)
if token is None:
raise exc.WrongArguments(_("Invalid token"))
project = self.get_object()
self.check_permissions(request, "transfer_accept", project)
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
request.user,
project,
)
if not enough_slots:
members = project.memberships.count()
raise exc.NotEnoughSlotsForProject(project.is_private, members, not_enough_slots_error)
reason = request.DATA.get('reason', None)
services.accept_project_transfer(project, request.user, token, reason)
return response.Ok()
def transfer_accept(self, request, pk=None):
token = request.DATA.get('token', None)
if token is None:
raise exc.WrongArguments(_("Invalid token"))
project = self.get_object()
self.check_permissions(request, "transfer_accept", project)
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
request.user,
project,
)
if not enough_slots:
members = project.memberships.count()
raise exc.NotEnoughSlotsForProject(project.is_private, members, not_enough_slots_error)
reason = request.DATA.get('reason', None)
services.accept_project_transfer(project, request.user, token, reason)
return response.Ok()
def dict_to_project(data, owner=None):
if owner:
data["owner"] = owner.email
members = len([
m for m in data.get("memberships", [])
if m.get("email", None) != data["owner"]
])
(enough_slots, not_enough_slots_error
) = users_service.has_available_slot_for_project(
owner, Project(is_private=data.get("is_private", False), id=None),
members)
if not enough_slots:
raise TaigaImportError(not_enough_slots_error)
project_serialized = service.store_project(data)
if not project_serialized:
raise TaigaImportError(_("error importing project data"))
proj = project_serialized.object
service.store_choices(proj, data, "points",
serializers.PointsExportSerializer)
service.store_choices(proj, data, "issue_types",
serializers.IssueTypeExportSerializer)
service.store_choices(proj, data, "issue_statuses",
serializers.IssueStatusExportSerializer)
service.store_choices(proj, data, "us_statuses",
serializers.UserStoryStatusExportSerializer)
service.store_choices(proj, data, "task_statuses",
serializers.TaskStatusExportSerializer)
service.store_choices(proj, data, "priorities",
serializers.PriorityExportSerializer)
service.store_choices(proj, data, "severities",
serializers.SeverityExportSerializer)
if service.get_errors(clear=False):
raise TaigaImportError(
_("error importing lists of project attributes"))
service.store_default_choices(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(
_("error importing default project attributes values"))
service.store_custom_attributes(
proj, data, "userstorycustomattributes",
serializers.UserStoryCustomAttributeExportSerializer)
service.store_custom_attributes(
proj, data, "taskcustomattributes",
serializers.TaskCustomAttributeExportSerializer)
service.store_custom_attributes(
proj, data, "issuecustomattributes",
serializers.IssueCustomAttributeExportSerializer)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing custom attributes"))
service.store_roles(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing roles"))
service.store_memberships(proj, data)
if proj.memberships.filter(user=proj.owner).count() == 0:
if proj.roles.all().count() > 0:
Membership.objects.create(project=proj,
email=proj.owner.email,
user=proj.owner,
role=proj.roles.all().first(),
is_admin=True)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing memberships"))
store_milestones(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing sprints"))
store_wiki_pages(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing wiki pages"))
store_wiki_links(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing wiki links"))
store_issues(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing issues"))
store_user_stories(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing user stories"))
store_tasks(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing tasks"))
store_tags_colors(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing tags"))
store_timeline_entries(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing timelines"))
proj.refresh_totals()
return proj
def create(self, request, *args, **kwargs):
self.check_permissions(request, 'import_project', None)
data = request.DATA.copy()
data['owner'] = data.get('owner', request.user.email)
is_private = data.get('is_private', False)
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
self.request.user,
project=Project(is_private=is_private, id=None)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
# Create Project
project_serialized = service.store_project(data)
if not project_serialized:
raise exc.BadRequest(service.get_errors())
# Create roles
roles_serialized = None
if "roles" in data:
roles_serialized = service.store_roles(project_serialized.object, data)
if not roles_serialized:
raise exc.BadRequest(_("We needed at least one role"))
# Create memberships
if "memberships" in data:
members = len(data['memberships'])
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
self.request.user,
project=Project(is_private=is_private, id=None),
members=max(members, 1)
)
if not enough_slots:
raise exc.BadRequest(not_enough_slots_error)
service.store_memberships(project_serialized.object, data)
try:
owner_membership = project_serialized.object.memberships.get(user=project_serialized.object.owner)
owner_membership.is_owner = True
owner_membership.save()
except Membership.DoesNotExist:
Membership.objects.create(
project=project_serialized.object,
email=project_serialized.object.owner.email,
user=project_serialized.object.owner,
role=project_serialized.object.roles.all().first(),
is_owner=True
)
# Create project values choicess
if "points" in data:
service.store_choices(project_serialized.object, data,
"points", serializers.PointsExportSerializer)
if "issue_types" in data:
service.store_choices(project_serialized.object, data,
"issue_types",
serializers.IssueTypeExportSerializer)
if "issue_statuses" in data:
service.store_choices(project_serialized.object, data,
"issue_statuses",
serializers.IssueStatusExportSerializer,)
if "us_statuses" in data:
service.store_choices(project_serialized.object, data,
"us_statuses",
serializers.UserStoryStatusExportSerializer,)
if "task_statuses" in data:
service.store_choices(project_serialized.object, data,
"task_statuses",
serializers.TaskStatusExportSerializer)
if "priorities" in data:
service.store_choices(project_serialized.object, data,
"priorities",
serializers.PriorityExportSerializer)
if "severities" in data:
service.store_choices(project_serialized.object, data,
"severities",
serializers.SeverityExportSerializer)
if ("points" in data or "issues_types" in data or
"issues_statuses" in data or "us_statuses" in data or
"task_statuses" in data or "priorities" in data or
"severities" in data):
service.store_default_choices(project_serialized.object, data)
# Created custom attributes
if "userstorycustomattributes" in data:
service.store_custom_attributes(project_serialized.object, data,
"userstorycustomattributes",
serializers.UserStoryCustomAttributeExportSerializer)
if "taskcustomattributes" in data:
service.store_custom_attributes(project_serialized.object, data,
"taskcustomattributes",
serializers.TaskCustomAttributeExportSerializer)
if "issuecustomattributes" in data:
service.store_custom_attributes(project_serialized.object, data,
"issuecustomattributes",
serializers.IssueCustomAttributeExportSerializer)
# Is there any error?
errors = service.get_errors()
if errors:
raise exc.BadRequest(errors)
# Importer process is OK
response_data = project_serialized.data
response_data['id'] = project_serialized.object.id
headers = self.get_success_headers(response_data)
return response.Created(response_data, headers=headers)
def dict_to_project(data, owner=None):
if owner:
data["owner"] = owner.email
members = len([m for m in data.get("memberships", []) if m.get("email", None) != data["owner"]])
(enough_slots, not_enough_slots_error) = users_service.has_available_slot_for_project(
owner,
Project(is_private=data.get("is_private", False), id=None),
members
)
if not enough_slots:
raise TaigaImportError(not_enough_slots_error)
project_serialized = service.store_project(data)
if not project_serialized:
raise TaigaImportError(_("error importing project data"))
proj = project_serialized.object
service.store_choices(proj, data, "points", serializers.PointsExportSerializer)
service.store_choices(proj, data, "issue_types", serializers.IssueTypeExportSerializer)
service.store_choices(proj, data, "issue_statuses", serializers.IssueStatusExportSerializer)
service.store_choices(proj, data, "us_statuses", serializers.UserStoryStatusExportSerializer)
service.store_choices(proj, data, "task_statuses", serializers.TaskStatusExportSerializer)
service.store_choices(proj, data, "priorities", serializers.PriorityExportSerializer)
service.store_choices(proj, data, "severities", serializers.SeverityExportSerializer)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing lists of project attributes"))
service.store_default_choices(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing default project attributes values"))
service.store_custom_attributes(proj, data, "userstorycustomattributes",
serializers.UserStoryCustomAttributeExportSerializer)
service.store_custom_attributes(proj, data, "taskcustomattributes",
serializers.TaskCustomAttributeExportSerializer)
service.store_custom_attributes(proj, data, "issuecustomattributes",
serializers.IssueCustomAttributeExportSerializer)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing custom attributes"))
service.store_roles(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing roles"))
service.store_memberships(proj, data)
if proj.memberships.filter(user=proj.owner).count() == 0:
if proj.roles.all().count() > 0:
Membership.objects.create(
project=proj,
email=proj.owner.email,
user=proj.owner,
role=proj.roles.all().first(),
is_admin=True
)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing memberships"))
store_milestones(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing sprints"))
store_wiki_pages(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing wiki pages"))
store_wiki_links(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing wiki links"))
store_issues(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing issues"))
store_user_stories(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing user stories"))
store_tasks(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing tasks"))
store_tags_colors(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing tags"))
store_timeline_entries(proj, data)
if service.get_errors(clear=False):
raise TaigaImportError(_("error importing timelines"))
proj.refresh_totals()
return proj
