Example #1
0
    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))
        except Exception:
            raise exc.WrongArguments(_("Invalid dump format"))

        slug = dump.get('slug', None)
        if slug is not None and Project.objects.filter(slug=slug).exists():
            del dump['slug']

        user = request.user
        dump['owner'] = user.email

        # Validate if the project can be imported
        is_private = dump.get("is_private", False)
        total_memberships = len([m for m in dump.get("memberships", [])
                                            if m.get("email", None) != dump["owner"]])
        total_memberships = total_memberships + 1 # 1 is the owner
        (enough_slots, error_message) = users_services.has_available_slot_for_import_new_project(
            user,
            is_private,
            total_memberships
        )
        if not enough_slots:
            raise exc.NotEnoughSlotsForProject(is_private, total_memberships, error_message)

        # Async mode
        if settings.CELERY_ENABLED:
            task = tasks.load_project_dump.delay(user, dump)
            return response.Accepted({"import_id": task.id})

        # Sync mode
        try:
            project = services.store_project_from_dict(dump, request.user)
        except err.TaigaImportError as e:
            # On Error
            ## remove project
            if e.project:
                e.project.delete_related_content()
                e.project.delete()

            return response.BadRequest({"error": e.message, "details": e.errors})
        else:
            # On Success
            response_data = ProjectSerializer(project).data
            return response.Created(response_data)
Example #2
0
def _validate_if_owner_have_enought_space_to_this_project(owner, data):
    # Validate if the owner can have this project
    data["owner"] = owner.email

    is_private = data.get("is_private", False)
    total_memberships = len([m for m in data.get("memberships", [])
                                        if m.get("email", None) != data["owner"]])
    total_memberships = total_memberships + 1 # 1 is the owner
    (enough_slots, error_message) = users_service.has_available_slot_for_import_new_project(
        owner,
        is_private,
        total_memberships
    )
    if not enough_slots:
        raise err.TaigaImportError(error_message, None)
Example #3
0
def _validate_if_owner_have_enought_space_to_this_project(owner, data):
    # Validate if the owner can have this project
    data["owner"] = owner.email

    is_private = data.get("is_private", False)
    total_memberships = len([m for m in data.get("memberships", [])
                                        if m.get("email", None) != data["owner"]])
    total_memberships = total_memberships + 1 # 1 is the owner
    (enough_slots, error_message) = users_service.has_available_slot_for_import_new_project(
        owner,
        is_private,
        total_memberships
    )
    if not enough_slots:
        raise err.TaigaImportError(error_message, None)
Example #4
0
    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))
        except Exception:
            raise exc.WrongArguments(_("Invalid dump format"))

        slug = dump.get('slug', None)
        if slug is not None and Project.objects.filter(slug=slug).exists():
            del dump['slug']

        user = request.user
        dump['owner'] = user.email

        # Validate if the project can be imported
        is_private = dump.get("is_private", False)
        total_memberships = len([
            m for m in dump.get("memberships", [])
            if m.get("email", None) != dump["owner"]
        ])
        total_memberships = total_memberships + 1  # 1 is the owner
        (enough_slots, error_message
         ) = users_service.has_available_slot_for_import_new_project(
             user, is_private, total_memberships)
        if not enough_slots:
            raise exc.NotEnoughSlotsForProject(is_private, total_memberships,
                                               error_message)

        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)
Example #5
0
    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)

        # Validate if the project can be imported
        is_private = data.get('is_private', False)
        total_memberships = len([
            m for m in data.get("memberships", [])
            if m.get("email", None) != data["owner"]
        ])
        total_memberships = total_memberships + 1  # 1 is the owner
        (enough_slots, error_message
         ) = users_services.has_available_slot_for_import_new_project(
             self.request.user, is_private, total_memberships)
        if not enough_slots:
            raise exc.NotEnoughSlotsForProject(is_private, total_memberships,
                                               error_message)

        # Create Project
        project_serialized = services.store.store_project(data)

        if not project_serialized:
            raise exc.BadRequest(services.store.get_errors())

        # Create roles
        roles_serialized = None
        if "roles" in data:
            roles_serialized = services.store.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:
            services.store.store_memberships(project_serialized.object, data)

        try:
            owner_membership = project_serialized.object.memberships.get(
                user=project_serialized.object.owner)
            owner_membership.is_admin = 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_admin=True)

        # Create project values choicess
        if "points" in data:
            services.store.store_project_attributes_values(
                project_serialized.object, data, "points",
                serializers.PointsExportSerializer)
        if "issue_types" in data:
            services.store.store_project_attributes_values(
                project_serialized.object, data, "issue_types",
                serializers.IssueTypeExportSerializer)
        if "issue_statuses" in data:
            services.store.store_project_attributes_values(
                project_serialized.object,
                data,
                "issue_statuses",
                serializers.IssueStatusExportSerializer,
            )
        if "us_statuses" in data:
            services.store.store_project_attributes_values(
                project_serialized.object,
                data,
                "us_statuses",
                serializers.UserStoryStatusExportSerializer,
            )
        if "task_statuses" in data:
            services.store.store_project_attributes_values(
                project_serialized.object, data, "task_statuses",
                serializers.TaskStatusExportSerializer)
        if "priorities" in data:
            services.store.store_project_attributes_values(
                project_serialized.object, data, "priorities",
                serializers.PriorityExportSerializer)
        if "severities" in data:
            services.store.store_project_attributes_values(
                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):
            services.store.store_default_project_attributes_values(
                project_serialized.object, data)

        # Created custom attributes
        if "userstorycustomattributes" in data:
            services.store.store_custom_attributes(
                project_serialized.object, data, "userstorycustomattributes",
                serializers.UserStoryCustomAttributeExportSerializer)

        if "taskcustomattributes" in data:
            services.store.store_custom_attributes(
                project_serialized.object, data, "taskcustomattributes",
                serializers.TaskCustomAttributeExportSerializer)

        if "issuecustomattributes" in data:
            services.store.store_custom_attributes(
                project_serialized.object, data, "issuecustomattributes",
                serializers.IssueCustomAttributeExportSerializer)

        # Is there any error?
        errors = services.store.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)
Example #6
0
    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)

        # Validate if the project can be imported
        is_private = data.get('is_private', False)
        total_memberships = len([m for m in data.get("memberships", [])
                                            if m.get("email", None) != data["owner"]])
        total_memberships = total_memberships + 1 # 1 is the owner
        (enough_slots, error_message) = users_services.has_available_slot_for_import_new_project(
            self.request.user,
            is_private,
            total_memberships
        )
        if not enough_slots:
            raise exc.NotEnoughSlotsForProject(is_private, total_memberships, error_message)

        # Create Project
        project_serialized = services.store.store_project(data)

        if not project_serialized:
            raise exc.BadRequest(services.store.get_errors())

        # Create roles
        roles_serialized = None
        if "roles" in data:
            roles_serialized = services.store.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:
            services.store.store_memberships(project_serialized.object, data)

        try:
            owner_membership = project_serialized.object.memberships.get(user=project_serialized.object.owner)
            owner_membership.is_admin = 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_admin=True
            )

        # Create project values choicess
        if "points" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "points", serializers.PointsExportSerializer)
        if "issue_types" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "issue_types",
                                                           serializers.IssueTypeExportSerializer)
        if "issue_statuses" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "issue_statuses",
                                                           serializers.IssueStatusExportSerializer,)
        if "us_statuses" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "us_statuses",
                                                           serializers.UserStoryStatusExportSerializer,)
        if "task_statuses" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "task_statuses",
                                                           serializers.TaskStatusExportSerializer)
        if "priorities" in data:
            services.store.store_project_attributes_values(project_serialized.object, data,
                                                           "priorities",
                                                           serializers.PriorityExportSerializer)
        if "severities" in data:
            services.store.store_project_attributes_values(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):
            services.store.store_default_project_attributes_values(project_serialized.object, data)

        # Created custom attributes
        if "userstorycustomattributes" in data:
            services.store.store_custom_attributes(project_serialized.object, data,
                                                   "userstorycustomattributes",
                                                   serializers.UserStoryCustomAttributeExportSerializer)

        if "taskcustomattributes" in data:
            services.store.store_custom_attributes(project_serialized.object, data,
                                                   "taskcustomattributes",
                                                   serializers.TaskCustomAttributeExportSerializer)

        if "issuecustomattributes" in data:
            services.store.store_custom_attributes(project_serialized.object, data,
                                                   "issuecustomattributes",
                                                   serializers.IssueCustomAttributeExportSerializer)

        # Is there any error?
        errors = services.store.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)
Example #7
0
def dict_to_project(data, owner=None):
    if owner:
        data["owner"] = owner.email

        # Validate if the owner can have this project
        is_private = data.get("is_private", False)
        total_memberships = len([
            m for m in data.get("memberships", [])
            if m.get("email", None) != data["owner"]
        ])
        total_memberships = total_memberships + 1  # 1 is the owner
        (enough_slots, error_message
         ) = users_service.has_available_slot_for_import_new_project(
             owner, is_private, total_memberships)
        if not enough_slots:
            raise TaigaImportError(error_message)

    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
Example #8
0
    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"))

        if dump.content_type == "application/gzip":
            dump = gzip.GzipFile(fileobj=dump)

        reader = codecs.getreader("utf-8")

        try:
            dump = json.load(reader(dump))
        except Exception:
            raise exc.WrongArguments(_("Invalid dump format"))

        slug = dump.get('slug', None)
        if slug is not None and Project.objects.filter(slug=slug).exists():
            del dump['slug']

        user = request.user
        dump['owner'] = user.email

        # Validate if the project can be imported
        is_private = dump.get("is_private", False)
        total_memberships = len([
            m for m in dump.get("memberships", [])
            if m.get("email", None) != dump["owner"]
        ])
        total_memberships = total_memberships + 1  # 1 is the owner
        (enough_slots, error_message
         ) = users_services.has_available_slot_for_import_new_project(
             user, is_private, total_memberships)
        if not enough_slots:
            raise exc.NotEnoughSlotsForProject(is_private, total_memberships,
                                               error_message)

        # Async mode
        if settings.CELERY_ENABLED:
            task = tasks.load_project_dump.delay(user, dump)
            return response.Accepted({"import_id": task.id})

        # Sync mode
        try:
            project = services.store_project_from_dict(dump, request.user)
        except err.TaigaImportError as e:
            # On Error
            ## remove project
            if e.project:
                e.project.delete_related_content()
                e.project.delete()

            return response.BadRequest({
                "error": e.message,
                "details": e.errors
            })
        else:
            # On Success
            response_data = ProjectSerializer(project).data
            return response.Created(response_data)
Example #9
0
def dict_to_project(data, owner=None):
    if owner:
        data["owner"] = owner.email

        # Validate if the owner can have this project
        is_private = data.get("is_private", False)
        total_memberships = len([m for m in data.get("memberships", [])
                                            if m.get("email", None) != data["owner"]])
        total_memberships = total_memberships + 1 # 1 is the owner
        (enough_slots, error_message) = users_service.has_available_slot_for_import_new_project(
            owner,
            is_private,
            total_memberships
        )
        if not enough_slots:
            raise TaigaImportError(error_message)

    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