class HighLightedContentSerializer(serializers.LightSerializer):
type = Field()
id = Field()
ref = Field()
slug = Field()
name = Field()
subject = Field()
description = MethodField()
assigned_to = Field()
status = Field()
status_color = Field()
tags_colors = MethodField()
created_date = Field()
is_private = MethodField()
logo_small_url = MethodField()
project = MethodField()
project_name = MethodField()
project_slug = MethodField()
project_is_private = MethodField()
project_blocked_code = Field()
assigned_to = Field(attr="assigned_to_id")
assigned_to_extra_info = MethodField()
is_watcher = MethodField()
total_watchers = Field()
def __init__(self, *args, **kwargs):
# Don't pass the extra ids args up to the superclass
self.user_watching = kwargs.pop("user_watching", {})
# Instantiate the superclass normally
super().__init__(*args, **kwargs)
def _none_if_project(self, obj, property):
type = getattr(obj, "type", "")
if type == "project":
return None
return getattr(obj, property)
def _none_if_not_project(self, obj, property):
type = getattr(obj, "type", "")
if type != "project":
return None
return getattr(obj, property)
def get_project(self, obj):
return self._none_if_project(obj, "project")
def get_is_private(self, obj):
return self._none_if_not_project(obj, "project_is_private")
def get_project_name(self, obj):
return self._none_if_project(obj, "project_name")
def get_description(self, obj):
return self._none_if_not_project(obj, "description")
def get_project_slug(self, obj):
return self._none_if_project(obj, "project_slug")
def get_project_is_private(self, obj):
return self._none_if_project(obj, "project_is_private")
def get_logo_small_url(self, obj):
logo = self._none_if_not_project(obj, "logo")
if logo:
return get_thumbnail_url(logo, settings.THN_LOGO_SMALL)
return None
def get_assigned_to_extra_info(self, obj):
assigned_to = None
if obj.assigned_to_extra_info is not None:
assigned_to = User(**obj.assigned_to_extra_info)
return UserBasicInfoSerializer(assigned_to).data
def get_tags_colors(self, obj):
tags = getattr(obj, "tags", [])
tags = tags if tags is not None else []
tags_colors = getattr(obj, "tags_colors", [])
tags_colors = tags_colors if tags_colors is not None else []
return [{
"name": tc[0],
"color": tc[1]
} for tc in tags_colors if tc[0] in tags]
def get_is_watcher(self, obj):
return obj.id in self.user_watching.get(obj.type, [])
class SeverityExportSerializer(RelatedExportSerializer):
name = Field()
order = Field()
color = Field()
class UserStorySerializer(CustomAttributesValuesWebhookSerializerMixin,
serializers.LightSerializer):
id = Field()
ref = Field()
project = ProjectSerializer()
is_closed = Field()
created_date = Field()
modified_date = Field()
finish_date = Field()
due_date = Field()
due_date_reason = Field()
subject = Field()
client_requirement = Field()
team_requirement = Field()
generated_from_issue = Field(attr="generated_from_issue_id")
generated_from_task = Field(attr="generated_from_task_id")
from_task_ref = Field()
external_reference = Field()
tribe_gig = Field()
watchers = MethodField()
is_blocked = Field()
blocked_note = Field()
description = Field()
tags = Field()
permalink = MethodField()
owner = UserSerializer()
assigned_to = UserSerializer()
assigned_users = MethodField()
points = MethodField()
status = UserStoryStatusSerializer()
milestone = MilestoneSerializer()
def get_permalink(self, obj):
return resolve_front_url("userstory", obj.project.slug, obj.ref)
def custom_attributes_queryset(self, project):
return project.userstorycustomattributes.all()
def get_assigned_users(self, obj):
"""Get the assigned of an object.
:return: User queryset object representing the assigned users
"""
return [user.id for user in obj.assigned_users.all()]
def get_watchers(self, obj):
return list(obj.get_watchers().values_list("id", flat=True))
def get_points(self, obj):
return RolePointsSerializer(obj.role_points.all(), many=True).data
class TimelineExportSerializer(RelatedExportSerializer):
data = TimelineDataField()
data_content_type = ContentTypeField()
event_type = Field()
created = DateTimeField()
class PointsExportSerializer(RelatedExportSerializer):
name = Field()
order = Field()
value = Field()
class UserStoryExportSerializer(CustomAttributesValuesExportSerializerMixin,
HistoryExportSerializerMixin,
AttachmentExportSerializerMixin,
WatcheableObjectLightSerializerMixin,
RelatedExportSerializer):
role_points = RolePointsExportSerializer(many=True)
owner = UserRelatedField()
assigned_to = UserRelatedField()
assigned_users = MethodField()
status = SlugRelatedField(slug_field="name")
milestone = SlugRelatedField(slug_field="name")
modified_date = DateTimeField()
created_date = DateTimeField()
finish_date = DateTimeField()
generated_from_issue = SlugRelatedField(slug_field="ref")
ref = Field()
is_closed = Field()
backlog_order = Field()
sprint_order = Field()
kanban_order = Field()
subject = Field()
description = Field()
client_requirement = Field()
team_requirement = Field()
external_reference = Field()
tribe_gig = Field()
version = Field()
blocked_note = Field()
is_blocked = Field()
tags = Field()
due_date = DateTimeField()
due_date_reason = Field()
def custom_attributes_queryset(self, project):
if project.id not in _custom_userstories_attributes_cache:
_custom_userstories_attributes_cache[project.id] = list(
project.userstorycustomattributes.all().values('id', 'name'))
return _custom_userstories_attributes_cache[project.id]
def statuses_queryset(self, project):
if project.id not in _userstories_statuses_cache:
_userstories_statuses_cache[project.id] = {
s.id: s.name
for s in project.us_statuses.all()
}
return _userstories_statuses_cache[project.id]
def get_assigned_users(self, obj):
return [user.email for user in obj.assigned_users.all()]
class EpicExportSerializer(CustomAttributesValuesExportSerializerMixin,
HistoryExportSerializerMixin,
AttachmentExportSerializerMixin,
WatcheableObjectLightSerializerMixin,
RelatedExportSerializer):
ref = Field()
owner = UserRelatedField()
status = SlugRelatedField(slug_field="name")
epics_order = Field()
created_date = DateTimeField()
modified_date = DateTimeField()
subject = Field()
description = Field()
color = Field()
assigned_to = UserRelatedField()
client_requirement = Field()
team_requirement = Field()
version = Field()
blocked_note = Field()
is_blocked = Field()
tags = Field()
related_user_stories = MethodField()
def get_related_user_stories(self, obj):
return EpicRelatedUserStoryExportSerializer(
obj.relateduserstory_set.filter(epic__project=obj.project),
many=True).data
def custom_attributes_queryset(self, project):
if project.id not in _custom_epics_attributes_cache:
_custom_epics_attributes_cache[project.id] = list(
project.epiccustomattributes.all().values('id', 'name'))
return _custom_epics_attributes_cache[project.id]
def statuses_queryset(self, project):
if project.id not in _epics_statuses_cache:
_epics_statuses_cache[project.id] = {
s.id: s.name
for s in project.epic_statuses.all()
}
return _epics_statuses_cache[project.id]
class ProjectTemplateSerializer(serializers.LightSerializer):
id = Field()
name = I18NField()
slug = Field()
description = I18NField()
order = Field()
created_date = Field()
modified_date = Field()
default_owner_role = Field()
is_backlog_activated = Field()
is_kanban_activated = Field()
is_wiki_activated = Field()
is_issues_activated = Field()
videoconferences = Field()
videoconferences_extra_data = Field()
default_options = Field()
us_statuses = Field()
points = Field()
task_statuses = Field()
issue_statuses = Field()
issue_types = Field()
priorities = Field()
severities = Field()
roles = Field()
class PrioritySerializer(serializers.LightSerializer):
id = Field()
name = I18NField()
order = Field()
color = Field()
project = Field(attr="project_id")
class ProjectDetailSerializer(ProjectSerializer):
us_statuses = Field(attr="userstory_statuses_attr")
points = Field(attr="points_attr")
task_statuses = Field(attr="task_statuses_attr")
issue_statuses = Field(attr="issue_statuses_attr")
issue_types = Field(attr="issue_types_attr")
priorities = Field(attr="priorities_attr")
severities = Field(attr="severities_attr")
userstory_custom_attributes = Field(
attr="userstory_custom_attributes_attr")
task_custom_attributes = Field(attr="task_custom_attributes_attr")
issue_custom_attributes = Field(attr="issue_custom_attributes_attr")
roles = Field(attr="roles_attr")
members = MethodField()
total_memberships = MethodField()
is_out_of_owner_limits = MethodField()
# Admin fields
is_private_extra_info = MethodField()
max_memberships = MethodField()
issues_csv_uuid = Field()
tasks_csv_uuid = Field()
userstories_csv_uuid = Field()
transfer_token = Field()
milestones = MethodField()
def get_milestones(self, obj):
assert hasattr(obj, "milestones_attr"
), "instance must have a milestones_attr attribute"
if obj.milestones_attr is None:
return []
return obj.milestones_attr
def to_value(self, instance):
# Name attributes must be translated
for attr in [
"userstory_statuses_attr", "points_attr", "task_statuses_attr",
"issue_statuses_attr", "issue_types_attr", "priorities_attr",
"severities_attr", "userstory_custom_attributes_attr",
"task_custom_attributes_attr", "issue_custom_attributes_attr",
"roles_attr"
]:
assert hasattr(
instance,
attr), "instance must have a {} attribute".format(attr)
val = getattr(instance, attr)
if val is None:
continue
for elem in val:
elem["name"] = _(elem["name"])
ret = super().to_value(instance)
admin_fields = [
"is_private_extra_info", "max_memberships", "issues_csv_uuid",
"tasks_csv_uuid", "userstories_csv_uuid", "transfer_token"
]
is_admin_user = False
if "request" in self.context:
user = self.context["request"].user
is_admin_user = permissions_services.is_project_admin(
user, instance)
if not is_admin_user:
for admin_field in admin_fields:
del (ret[admin_field])
return ret
def get_members(self, obj):
assert hasattr(
obj, "members_attr"), "instance must have a members_attr attribute"
if obj.members_attr is None:
return []
return MembershipDictSerializer(
[m for m in obj.members_attr if m['id'] is not None],
many=True).data
def get_total_memberships(self, obj):
if obj.members_attr is None:
return 0
return len(obj.members_attr)
def get_is_out_of_owner_limits(self, obj):
assert hasattr(
obj, "private_projects_same_owner_attr"
), "instance must have a private_projects_same_owner_attr attribute"
assert hasattr(
obj, "public_projects_same_owner_attr"
), "instance must have a public_projects_same_owner_attr attribute"
return services.check_if_project_is_out_of_owner_limits(
obj,
current_memberships=self.get_total_memberships(obj),
current_private_projects=obj.private_projects_same_owner_attr,
current_public_projects=obj.public_projects_same_owner_attr)
def get_is_private_extra_info(self, obj):
assert hasattr(
obj, "private_projects_same_owner_attr"
), "instance must have a private_projects_same_owner_attr attribute"
assert hasattr(
obj, "public_projects_same_owner_attr"
), "instance must have a public_projects_same_owner_attr attribute"
return services.check_if_project_privacity_can_be_changed(
obj,
current_memberships=self.get_total_memberships(obj),
current_private_projects=obj.private_projects_same_owner_attr,
current_public_projects=obj.public_projects_same_owner_attr)
def get_max_memberships(self, obj):
return services.get_max_memberships_for_project(obj)
class PointsSerializer(serializers.LightSerializer):
id = Field()
name = I18NField()
order = Field()
value = Field()
project = Field(attr="project_id")
class ProjectSerializer(serializers.LightSerializer):
id = Field()
name = Field()
slug = Field()
description = Field()
created_date = Field()
modified_date = Field()
owner = MethodField()
members = MethodField()
total_milestones = Field()
total_story_points = Field()
is_backlog_activated = Field()
is_kanban_activated = Field()
is_wiki_activated = Field()
is_issues_activated = Field()
videoconferences = Field()
videoconferences_extra_data = Field()
creation_template = Field(attr="creation_template_id")
is_private = Field()
anon_permissions = Field()
public_permissions = Field()
is_featured = Field()
is_looking_for_people = Field()
looking_for_people_note = Field()
blocked_code = Field()
totals_updated_datetime = Field()
total_fans = Field()
total_fans_last_week = Field()
total_fans_last_month = Field()
total_fans_last_year = Field()
total_activity = Field()
total_activity_last_week = Field()
total_activity_last_month = Field()
total_activity_last_year = Field()
tags = Field()
tags_colors = MethodField()
default_points = Field(attr="default_points_id")
default_us_status = Field(attr="default_us_status_id")
default_task_status = Field(attr="default_task_status_id")
default_priority = Field(attr="default_priority_id")
default_severity = Field(attr="default_severity_id")
default_issue_status = Field(attr="default_issue_status_id")
default_issue_type = Field(attr="default_issue_type_id")
my_permissions = MethodField()
i_am_owner = MethodField()
i_am_admin = MethodField()
i_am_member = MethodField()
notify_level = MethodField()
total_closed_milestones = MethodField()
is_watcher = MethodField()
total_watchers = MethodField()
logo_small_url = MethodField()
logo_big_url = MethodField()
is_fan = Field(attr="is_fan_attr")
def get_members(self, obj):
assert hasattr(
obj, "members_attr"), "instance must have a members_attr attribute"
if obj.members_attr is None:
return []
return [m.get("id") for m in obj.members_attr if m["id"] is not None]
def get_i_am_member(self, obj):
assert hasattr(
obj, "members_attr"), "instance must have a members_attr attribute"
if obj.members_attr is None:
return False
if "request" in self.context:
user = self.context["request"].user
user_ids = [
m.get("id") for m in obj.members_attr if m["id"] is not None
]
if not user.is_anonymous() and user.id in user_ids:
return True
return False
def get_tags_colors(self, obj):
return dict(obj.tags_colors)
def get_my_permissions(self, obj):
if "request" in self.context:
user = self.context["request"].user
return calculate_permissions(
is_authenticated=user.is_authenticated(),
is_superuser=user.is_superuser,
is_member=self.get_i_am_member(obj),
is_admin=self.get_i_am_admin(obj),
role_permissions=obj.my_role_permissions_attr,
anon_permissions=obj.anon_permissions,
public_permissions=obj.public_permissions)
return []
def get_owner(self, obj):
return UserBasicInfoSerializer(obj.owner).data
def get_i_am_owner(self, obj):
if "request" in self.context:
return is_project_owner(self.context["request"].user, obj)
return False
def get_i_am_admin(self, obj):
if "request" in self.context:
return is_project_admin(self.context["request"].user, obj)
return False
def get_total_closed_milestones(self, obj):
assert hasattr(
obj, "closed_milestones_attr"
), "instance must have a closed_milestones_attr attribute"
return obj.closed_milestones_attr
def get_is_watcher(self, obj):
assert hasattr(obj, "notify_policies_attr"
), "instance must have a notify_policies_attr attribute"
np = self.get_notify_level(obj)
return np is not None and np != NotifyLevel.none
def get_total_watchers(self, obj):
assert hasattr(obj, "notify_policies_attr"
), "instance must have a notify_policies_attr attribute"
if obj.notify_policies_attr is None:
return 0
valid_notify_policies = [
np for np in obj.notify_policies_attr
if np["notify_level"] != NotifyLevel.none
]
return len(valid_notify_policies)
def get_notify_level(self, obj):
assert hasattr(obj, "notify_policies_attr"
), "instance must have a notify_policies_attr attribute"
if obj.notify_policies_attr is None:
return None
if "request" in self.context:
user = self.context["request"].user
for np in obj.notify_policies_attr:
if np["user_id"] == user.id:
return np["notify_level"]
return None
def get_logo_small_url(self, obj):
return services.get_logo_small_thumbnail_url(obj)
def get_logo_big_url(self, obj):
return services.get_logo_big_thumbnail_url(obj)
class MembershipAdminSerializer(MembershipSerializer):
email = Field()
user_email = MethodField()
def get_user_email(self, obj):
return obj.user.email if obj.user else None
class ContactProjectDetailSerializer(serializers.LightSerializer):
id = Field()
slug = Field()
name = Field()
class IssueCustomAttributesValuesExportSerializer(
BaseCustomAttributesValuesExportSerializer):
issue = Field(attr="issue.id")
class IssueTypeSerializer(serializers.LightSerializer):
id = Field()
name = I18NField()
order = Field()
color = Field()
project = Field(attr="project_id")
class TaskExportSerializer(CustomAttributesValuesExportSerializerMixin,
HistoryExportSerializerMixin,
AttachmentExportSerializerMixin,
WatcheableObjectLightSerializerMixin,
RelatedExportSerializer):
owner = UserRelatedField()
status = SlugRelatedField(slug_field="name")
user_story = SlugRelatedField(slug_field="ref")
milestone = SlugRelatedField(slug_field="name")
assigned_to = UserRelatedField()
modified_date = DateTimeField()
created_date = DateTimeField()
finished_date = DateTimeField()
ref = Field()
subject = Field()
us_order = Field()
taskboard_order = Field()
description = Field()
is_iocaine = Field()
external_reference = Field()
version = Field()
blocked_note = Field()
is_blocked = Field()
tags = Field()
due_date = DateTimeField()
due_date_reason = Field()
def custom_attributes_queryset(self, project):
if project.id not in _custom_tasks_attributes_cache:
_custom_tasks_attributes_cache[project.id] = list(
project.taskcustomattributes.all().values('id', 'name'))
return _custom_tasks_attributes_cache[project.id]
def statuses_queryset(self, project):
if project.id not in _tasks_statuses_cache:
_tasks_statuses_cache[project.id] = {
s.id: s.name
for s in project.task_statuses.all()
}
return _tasks_statuses_cache[project.id]
class IssueListSerializer(
VoteResourceSerializerMixin, WatchedResourceSerializer,
OwnerExtraInfoSerializerMixin, AssignedToExtraInfoSerializerMixin,
StatusExtraInfoSerializerMixin, ProjectExtraInfoSerializerMixin,
BasicAttachmentsInfoSerializerMixin, DueDateSerializerMixin,
TaggedInProjectResourceSerializer, serializers.LightSerializer):
id = Field()
ref = Field()
severity = Field(attr="severity_id")
priority = Field(attr="priority_id")
type = Field(attr="type_id")
milestone = Field(attr="milestone_id")
project = Field(attr="project_id")
created_date = Field()
modified_date = Field()
finished_date = Field()
subject = Field()
external_reference = Field()
version = Field()
watchers = Field()
is_blocked = Field()
blocked_note = Field()
is_closed = Field()
class EpicRelatedUserStoryExportSerializer(RelatedExportSerializer):
user_story = SlugRelatedField(slug_field="ref")
order = Field()
class WikiLinkSerializer(serializers.LightSerializer):
id = Field()
project = Field(attr="project_id")
title = Field()
href = Field()
order = Field()
class WikiLinkExportSerializer(RelatedExportSerializer):
title = Field()
href = Field()
order = Field()
class RoleExportSerializer(RelatedExportSerializer):
name = Field()
slug = Field()
order = Field()
computable = Field()
permissions = Field()
class ProjectExportSerializer(WatcheableObjectLightSerializerMixin):
name = Field()
slug = Field()
description = Field()
created_date = DateTimeField()
logo = FileField()
total_milestones = Field()
total_story_points = Field()
is_epics_activated = Field()
is_backlog_activated = Field()
is_kanban_activated = Field()
is_wiki_activated = Field()
is_issues_activated = Field()
videoconferences = Field()
videoconferences_extra_data = Field()
creation_template = SlugRelatedField(slug_field="slug")
is_private = Field()
is_featured = Field()
is_looking_for_people = Field()
looking_for_people_note = Field()
epics_csv_uuid = Field()
userstories_csv_uuid = Field()
tasks_csv_uuid = Field()
issues_csv_uuid = Field()
transfer_token = Field()
blocked_code = Field()
totals_updated_datetime = DateTimeField()
total_fans = Field()
total_fans_last_week = Field()
total_fans_last_month = Field()
total_fans_last_year = Field()
total_activity = Field()
total_activity_last_week = Field()
total_activity_last_month = Field()
total_activity_last_year = Field()
anon_permissions = Field()
public_permissions = Field()
modified_date = DateTimeField()
roles = RoleExportSerializer(many=True)
owner = UserRelatedField()
memberships = MembershipExportSerializer(many=True)
points = PointsExportSerializer(many=True)
epic_statuses = EpicStatusExportSerializer(many=True)
us_statuses = UserStoryStatusExportSerializer(many=True)
task_statuses = TaskStatusExportSerializer(many=True)
issue_types = IssueTypeExportSerializer(many=True)
issue_statuses = IssueStatusExportSerializer(many=True)
priorities = PriorityExportSerializer(many=True)
severities = SeverityExportSerializer(many=True)
tags_colors = Field()
default_points = SlugRelatedField(slug_field="name")
default_epic_status = SlugRelatedField(slug_field="name")
default_us_status = SlugRelatedField(slug_field="name")
default_task_status = SlugRelatedField(slug_field="name")
default_priority = SlugRelatedField(slug_field="name")
default_severity = SlugRelatedField(slug_field="name")
default_issue_status = SlugRelatedField(slug_field="name")
default_issue_type = SlugRelatedField(slug_field="name")
epiccustomattributes = EpicCustomAttributesExportSerializer(many=True)
userstorycustomattributes = UserStoryCustomAttributeExportSerializer(
many=True)
taskcustomattributes = TaskCustomAttributeExportSerializer(many=True)
issuecustomattributes = IssueCustomAttributeExportSerializer(many=True)
epics = EpicExportSerializer(many=True)
user_stories = UserStoryExportSerializer(many=True)
tasks = TaskExportSerializer(many=True)
milestones = MilestoneExportSerializer(many=True)
issues = IssueExportSerializer(many=True)
wiki_links = WikiLinkExportSerializer(many=True)
wiki_pages = WikiPageExportSerializer(many=True)
tags = Field()
class BaseCustomAttributesValuesExportSerializer(RelatedExportSerializer):
attributes_values = Field(required=True)
class IssueStatusExportSerializer(RelatedExportSerializer):
name = Field()
slug = Field()
order = Field()
is_closed = Field()
color = Field()
class UserStoryCustomAttributesValuesExportSerializer(
BaseCustomAttributesValuesExportSerializer):
user_story = Field(attr="user_story.id")
class IssueTypeExportSerializer(RelatedExportSerializer):
name = Field()
order = Field()
color = Field()
class TaskCustomAttributesValuesExportSerializer(
BaseCustomAttributesValuesExportSerializer):
task = Field(attr="task.id")
class TaskSerializer(CustomAttributesValuesWebhookSerializerMixin,
serializers.LightSerializer):
id = Field()
ref = Field()
created_date = Field()
modified_date = Field()
finished_date = Field()
due_date = Field()
due_date_reason = Field()
subject = Field()
us_order = Field()
taskboard_order = Field()
is_iocaine = Field()
external_reference = Field()
watchers = MethodField()
is_blocked = Field()
blocked_note = Field()
description = Field()
tags = Field()
permalink = MethodField()
project = ProjectSerializer()
owner = UserSerializer()
assigned_to = UserSerializer()
status = TaskStatusSerializer()
user_story = UserStorySerializer()
milestone = MilestoneSerializer()
promoted_to = MethodField()
def get_permalink(self, obj):
return resolve_front_url("task", obj.project.slug, obj.ref)
def custom_attributes_queryset(self, project):
return project.taskcustomattributes.all()
def get_watchers(self, obj):
return list(obj.get_watchers().values_list("id", flat=True))
def get_promoted_to(self, obj):
return list(obj.generated_user_stories.values_list("id", flat=True))
class NotificationSerializer(serializers.LightSerializer):
id = Field()
created_date = Field()
project_id = Field()
notification_type = Field()
message = Field()
