def create_template(self, request, **kwargs): template_name = request.DATA.get('template_name', None) template_description = request.DATA.get('template_description', None) if not template_name: raise response.BadRequest(_("Invalid template name")) if not template_description: raise response.BadRequest(_("Invalid template description")) with advisory_lock("create-project-template"): template_slug = slugify_uniquely(template_name, models.ProjectTemplate) project = self.get_object() self.check_permissions(request, 'create_template', project) template = models.ProjectTemplate( name=template_name, slug=template_slug, description=template_description, ) template.load_data_from_project(project) template.save() return response.Created( serializers.ProjectTemplateSerializer(template).data)
def update(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) self.object = self.get_object_or_none() self.check_permissions(request, 'update', self.object) if self.object is None: raise Http404 serializer = self.get_serializer(self.object, data=request.DATA, files=request.FILES, partial=partial) if not serializer.is_valid(): return response.BadRequest(serializer.errors) # Hooks try: self.pre_save(serializer.object) self.pre_conditions_on_save(serializer.object) except ValidationError as err: # full_clean on model instance may be called in pre_save, # so we have to handle eventual errors. return response.BadRequest(err.message_dict) if self.object is None: self.object = serializer.save(force_insert=True) self.post_save(self.object, created=True) return response.Created(serializer.data) self.object = serializer.save(force_update=True) self.post_save(self.object, created=False) return response.Ok(serializer.data)
def _private_register(self, request): data = parse_private_register_data(request.DATA) user = private_register_for_new_user(request.DATA.get("push_id"), **data) data = make_auth_response_data(user) return response.Created(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)) except Exception: raise exc.WrongArguments(_("Invalid dump format")) if Project.objects.filter(slug=dump['slug']).exists(): del dump['slug'] if settings.CELERY_ENABLED: task = tasks.load_project_dump.delay(request.user, dump) return response.Accepted({"import_id": task.id}) project = dump_service.dict_to_project(dump, request.user.email) response_data = ProjectSerializer(project).data return response.Created(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 _public_register(self, request): if not settings.PUBLIC_REGISTER_ENABLED: raise exc.BadRequest(_("Public register is disabled.")) try: data = parse_public_register_data(request.DATA) user = public_register(**data) except exc.IntegrityError as e: raise exc.BadRequest(e.detail) data = make_auth_response_data(user) return response.Created(data)
def _private_register(self, request): register_type = parse_register_type(request.DATA) if register_type is RegisterTypeEnum.existing_user: data = parse_private_register_for_existing_user_data(request.DATA) user = private_register_for_existing_user(**data) else: data = parse_private_register_for_new_user_data(request.DATA) user = private_register_for_new_user(**data) data = make_auth_response_data(user) return response.Created(data)
def us(self, request, *args, **kwargs): project = self.get_object_or_none() self.check_permissions(request, 'import_item', project) us = services.store.store_user_story(project, request.DATA.copy()) errors = services.store.get_errors() if errors: raise exc.BadRequest(errors) headers = self.get_success_headers(us.data) return response.Created(us.data, headers=headers)
def wiki_link(self, request, *args, **kwargs): project = self.get_object_or_none() self.check_permissions(request, 'import_item', project) wiki_link = services.store.store_wiki_link(project, request.DATA.copy()) errors = services.store.get_errors() if errors: raise exc.BadRequest(errors) data = serializers.WikiLinkExportSerializer(wiki_link.object).data headers = self.get_success_headers(data) return response.Created(data, headers=headers)
def milestone(self, request, *args, **kwargs): project = self.get_object_or_none() self.check_permissions(request, "import_item", project) milestone = services.store.store_milestone(project, request.DATA.copy()) errors = services.store.get_errors() if errors: raise exc.BadRequest(errors) data = serializers.MilestoneExportSerializer(milestone.object).data headers = self.get_success_headers(data) return response.Created(data, headers=headers)
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.DATA, files=request.FILES) if serializer.is_valid(): self.check_permissions(request, 'create', serializer.object) self.pre_save(serializer.object) self.pre_conditions_on_save(serializer.object) self.object = serializer.save(force_insert=True) self.post_save(self.object, created=True) headers = self.get_success_headers(serializer.data) return response.Created(serializer.data, headers=headers) return response.BadRequest(serializer.errors)
def issue(self, request, *args, **kwargs): project = self.get_object_or_none() self.check_permissions(request, 'import_item', project) signals.pre_save.disconnect( sender=Issue, dispatch_uid="set_finished_date_when_edit_issue") issue = services.store.store_issue(project, request.DATA.copy()) errors = services.store.get_errors() if errors: raise exc.BadRequest(errors) headers = self.get_success_headers(issue.data) return response.Created(issue.data, headers=headers)
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 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)
def task(self, request, *args, **kwargs): project = self.get_object_or_none() self.check_permissions(request, 'import_item', project) signals.pre_save.disconnect( sender=Task, dispatch_uid="set_finished_date_when_edit_task") task = services.store.store_task(project, request.DATA.copy()) errors = services.store.get_errors() if errors: raise exc.BadRequest(errors) data = serializers.TaskExportSerializer(task.object).data headers = self.get_success_headers(data) return response.Created(data, headers=headers)
def create(self, request, *args, **kwargs): validator = self.get_validator(data=request.DATA, files=request.FILES) if validator.is_valid(): self.check_permissions(request, "create", validator.object) self.pre_save(validator.object) self.pre_conditions_on_save(validator.object) self.object = validator.save(force_insert=True) self.post_save(self.object, created=True) instance = self.get_queryset().get(id=self.object.id) serializer = self.get_serializer(instance) headers = self.get_success_headers(serializer.data) return response.Created(serializer.data, headers=headers) return response.BadRequest(validator.errors)
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 new_name = data.get("name", "") new_description = data.get("description", "") new_owner = self.request.user new_is_private = data.get('is_private', False) new_members = data.get("users", []) # Validate if the project can be imported (enough_slots, error_message, total_members) = services.check_if_project_can_be_duplicate( project=project, new_owner=new_owner, new_is_private=new_is_private, new_user_id_members=[m["id"] for m in new_members]) if not enough_slots: raise exc.NotEnoughSlotsForProject(new_is_private, total_members, error_message) new_project = services.duplicate_project(project=project, name=new_name, description=new_description, owner=new_owner, is_private=new_is_private, users=new_members) new_project = get_object_or_error(self.get_queryset(), request.user, id=new_project.id) serializer = self.get_serializer(new_project) return response.Created(serializer.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")) 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_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 project_from_qs = project_utils.attach_extra_info( Project.objects.all()).get(id=project.id) response_data = ProjectSerializer(project_from_qs).data return response.Created(response_data)
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) # 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: 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 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)
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) project_serialized = service.store_project(data) if project_serialized is None: raise exc.BadRequest(service.get_errors()) 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) 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) if "roles" in data: service.store_roles(project_serialized.object, data) if "memberships" in data: service.store_memberships(project_serialized.object, data) if project_serialized.object.memberships.filter( user=project_serialized.object.owner).count() == 0: if project_serialized.object.roles.all().count() > 0: 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) errors = service.get_errors() if errors: raise exc.BadRequest(errors) 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)