def to_review_task(task, output_file_dict):
to_review_status = get_to_review_status()
task_dict_before = task.serialize()
task.update({"task_status_id": to_review_status.id})
task.save()
project = Project.get(task.project_id)
entity = Entity.get(task.entity_id)
entity_type = EntityType.get(entity.entity_type_id)
person = Person.get(output_file_dict["person_id"])
task_dict_after = task.serialize()
task_dict_after["output_file"] = output_file_dict
task_dict_after["project"] = project.serialize()
task_dict_after["entity"] = entity.serialize()
task_dict_after["entity_type"] = entity_type.serialize()
task_dict_after["person"] = person.serialize()
events.emit("task:to-review", {
"task_before": task_dict_before,
"task_after": task_dict_after
})
return task
def test_create_person_with_departments(self):
self.generate_fixture_department()
departments = [
str(department.id) for department in Department.query.all()
]
data = {
"first_name": "John2",
"last_name": "Doe",
"email": "*****@*****.**",
"departments": departments,
}
person = self.post("data/persons/new", data)
self.assertIsNotNone(person["id"])
self.assertEquals(
set(person["departments"]),
set(departments),
)
created_person = Person.get(person["id"])
self.assertEquals(
set(
str(department.id) for department in created_person.departments
),
set(departments),
)
def test_present(self):
person = self.get_first("data/persons")
person_model = Person.get(person["id"])
person_dict = person_model.present_minimal()
self.assertEquals(person_dict["departments"], [])
person_dict = person_model.present_minimal(relations=True)
self.assertEquals(person_dict["departments"], [])
def test_person(self):
person_dict = {
"departments": [ ],
"id": "b86127df-909b-4bc2-983e-a959ea5a7319",
"created_at": "2019-06-29T15:05:22",
"updated_at": "2019-06-29T15:05:22",
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"phone": "",
"active": True,
"desktop_login": "",
"timezone": "Europe/Paris",
"locale": "en_US",
"role": "user",
"has_avatar": True,
"notifications_enabled": False,
"notifications_slack_enabled": False,
"notifications_slack_userid": None,
"type": "Person",
"full_name": "John Doe"
}
Person.create_from_import(person_dict)
person = Person.get(person_dict["id"])
self.assertEqual(person.first_name, person_dict["first_name"])
def update_person(person_id, data):
"""
Update person entry with data given in parameter.
"""
person = Person.get(person_id)
person.update(data)
return person.serialize()
def extract_assignees(self, sg_task, person_ids):
assignees = []
if len(sg_task["task_assignees"]) > 0:
for sg_person in sg_task["task_assignees"]:
person_id = person_ids[sg_person["id"]]
person = Person.get(person_id)
assignees.append(person)
return assignees
def delete_person(person_id):
"""
Delete person entry from database.
"""
person = Person.get(person_id)
person_dict = person.serialize()
person.delete()
return person_dict
def add_team_member(project_id, person_id):
"""
Add a a person listed in database to the the project team.
"""
project = get_project_raw(project_id)
person = Person.get(person_id)
project.team.append(person)
project.save()
return project.serialize()
def set_mentions(self, person_ids):
from zou.app.models.person import Person
self.mentions = []
for person_id in person_ids:
person = Person.get(person_id)
if person is not None:
self.mentions.append(person)
self.save()
def get_person(person_id):
try:
person = Person.get(person_id)
except StatementError:
raise PersonNotFoundException()
if person is None:
raise PersonNotFoundException()
return person
def remove_team_member(project_id, person_id):
"""
Remove a a person listed in database from the the project team.
"""
project = get_project_raw(project_id)
person = Person.get(person_id)
project.team.remove(person)
project.save()
return project.serialize()
def delete_person(person_id):
"""
Delete person entry from database.
"""
person = Person.get(person_id)
person_dict = person.serialize()
person.delete()
events.emit("person:delete", {"person_id": person_id})
clear_person_cache()
return person_dict
def remove_person(person_id, force=True):
person = Person.get(person_id)
if force:
for comment in Comment.get_all_by(person_id=person_id):
remove_comment(comment.id)
comments = Comment.query.filter(
Comment.acknowledgements.contains(person)
)
for comment in comments:
comment.acknowledgements = [
member
for member in comment.acknowledgements
if str(member.id) != person_id
]
comment.save()
ApiEvent.delete_all_by(user_id=person_id)
Notification.delete_all_by(person_id=person_id)
SearchFilter.delete_all_by(person_id=person_id)
DesktopLoginLog.delete_all_by(person_id=person_id)
LoginLog.delete_all_by(person_id=person_id)
Subscription.delete_all_by(person_id=person_id)
TimeSpent.delete_all_by(person_id=person_id)
for project in Project.query.filter(Project.team.contains(person)):
project.team = [
member
for member in project.team
if str(member.id) != person_id
]
project.save()
for task in Task.query.filter(Task.assignees.contains(person)):
task.assignees = [
assignee
for assignee in task.assignees
if str(assignee.id) != person_id
]
task.save()
for task in Task.get_all_by(assigner_id=person_id):
task.update({"assigner_id": None})
for output_file in OutputFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
for working_file in WorkingFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
for task in WorkingFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
try:
person.delete()
events.emit("person:delete", {"person_id": person.id})
except IntegrityError:
raise ModelWithRelationsDeletionException(
"Some data are still linked to given person."
)
return person.serialize_safe()
def update_person(person_id, data):
"""
Update person entry with data given in parameter.
"""
person = Person.get(person_id)
person.update(data)
events.emit("person:update", {
"person_id": person_id
})
clear_person_cache()
return person.serialize()
def remove_team_member(project_id, person_id):
"""
Remove a a person listed in database from the the project team.
"""
project = get_project_raw(project_id)
person = Person.get(person_id)
project.team.remove(person)
project.save()
clear_project_cache(str(project_id))
events.emit("project:update", {"project_id": project_id})
return project.serialize()
def add_team_member(project_id, person_id):
"""
Add a a person listed in database to the the project team.
"""
project = get_project_raw(project_id)
person = Person.get(person_id)
project.team.append(person)
project.save()
clear_project_cache(str(project_id))
events.emit("project:update", {"project_id": project_id})
return project.serialize()
def test_add_logs(self):
person = persons_service.get_person_by_email("*****@*****.**")
person_raw = Person.get(person["id"])
person_raw.update({"email": "*****@*****.**"})
person = persons_service.get_person_by_email("*****@*****.**")
person = persons_service.update_person(
person["id"], {"email": "*****@*****.**"})
with pytest.raises(PersonNotFoundException):
persons_service.get_person_by_email("*****@*****.**")
person = persons_service.get_person_by_email("*****@*****.**")
def update_person(person_id, data):
"""
Update person entry with data given in parameter.
"""
person = Person.get(person_id)
if "email" in data and data["email"] is not None:
data["email"] = data["email"].strip()
person.update(data)
events.emit("person:update", {"person_id": person_id})
clear_person_cache()
return person.serialize()
def get_person_raw(person_id):
"""
Return given person as an active record.
"""
if person_id is None:
raise PersonNotFoundException()
try:
person = Person.get(person_id)
except StatementError:
raise PersonNotFoundException()
if person is None:
raise PersonNotFoundException()
return person
def test_update_person_with_departments(self):
self.generate_fixture_department()
person = self.get_first("data/persons")
departments = [
str(department.id) for department in Department.query.all()
]
data = {
"first_name": "Johnny",
"departments": departments,
}
self.put("data/persons/%s" % person["id"], data)
person_again = Person.get(person["id"])
self.assertEquals(
set(str(department.id) for department in person_again.departments),
set(departments),
)
def get_person_related_tasks(person_id, task_type_id):
"""
Retrieve all tasks for given task types and to entiities
that have at least one person assignation.
"""
person = Person.get(person_id)
projects = projects_service.open_projects()
project_ids = [project["id"] for project in projects]
entities = (Entity.query.join(Task, Entity.id == Task.entity_id).filter(
Task.assignees.contains(person)).filter(
Entity.project_id.in_(project_ids))).all()
entity_ids = [entity.id for entity in entities]
tasks = (Task.query.filter(Task.entity_id.in_(entity_ids)).filter(
Task.task_type_id == task_type_id)).all()
return fields.serialize_models(tasks)
def test_get_open_projects(self):
projects = self.get("data/user/projects/open")
self.assertEqual(len(projects), 0)
project = Project.get(self.project_id)
person = Person.get(self.user_id)
project.team.append(person)
project.save()
projects = self.get("data/user/projects/open")
self.assertEqual(len(projects), 1)
project = Project.get(self.project_id)
project.team[:] = []
project.save()
projects = self.get("data/user/projects/open")
self.assertEqual(len(projects), 0)
def get(self, instance_id):
try:
task = task_info.get_task(instance_id)
except TaskNotFoundException:
abort(404)
result = task.serialize()
task_type = TaskType.get(task.task_type_id)
result["task_type"] = task_type.serialize()
assigner = Person.get(task.assigner_id)
result["assigner"] = assigner.serialize()
project = Project.get(task.project_id)
result["project"] = project.serialize()
task_status = TaskStatus.get(task.task_status_id)
result["task_status"] = task_status.serialize()
entity = Entity.get(task.entity_id)
result["entity"] = entity.serialize()
assignees = []
for assignee in task.assignees:
assignees.append(assignee.serialize())
result["persons"] = assignees
return result, 200
def get_current_user_raw(self):
return Person.get(self.user["id"])
def get_person_tasks(person_id, projects, is_done=None):
person = Person.get(person_id)
project_ids = [project["id"] for project in projects]
Sequence = aliased(Entity, name='sequence')
Episode = aliased(Entity, name='episode')
query = Task.query \
.join(Project, TaskType, TaskStatus) \
.join(Entity, Entity.id == Task.entity_id) \
.join(EntityType, EntityType.id == Entity.entity_type_id) \
.outerjoin(Sequence, Sequence.id == Entity.parent_id) \
.outerjoin(Episode, Episode.id == Sequence.parent_id) \
.filter(Task.assignees.contains(person)) \
.filter(Project.id.in_(project_ids)) \
.add_columns(
Project.name,
Entity.name,
Entity.preview_file_id,
EntityType.name,
Sequence.name,
Episode.name,
TaskType.name,
TaskStatus.name,
TaskType.color,
TaskStatus.color,
TaskStatus.short_name
)
if is_done:
query = query \
.filter(TaskStatus.is_done == True) \
.order_by(Task.end_date.desc(), TaskType.name, Entity.name)
else:
query = query.filter(TaskStatus.is_done == False)
tasks = []
for (task, project_name, entity_name, entity_preview_file_id,
entity_type_name, sequence_name, episode_name, task_type_name,
task_status_name, task_type_color, task_status_color,
task_status_short_name) in query.all():
if entity_preview_file_id is None:
entity_preview_file_id = ""
task_dict = task.serialize()
task_dict.update({
"project_name": project_name,
"entity_name": entity_name,
"entity_preview_file_id": str(entity_preview_file_id),
"entity_type_name": entity_type_name,
"sequence_name": sequence_name,
"episode_name": episode_name,
"task_type_name": task_type_name,
"task_status_name": task_status_name,
"task_type_color": task_type_color,
"task_status_color": task_status_color,
"task_status_short_name": task_status_short_name
})
tasks.append(task_dict)
task_ids = [task["id"] for task in tasks]
task_comment_map = {}
comments = Comment.query \
.filter(Comment.object_id.in_(task_ids)) \
.order_by(Comment.object_id, Comment.created_at) \
.all()
task_id = None
for comment in comments:
if comment.object_id != task_id:
task_id = fields.serialize_value(comment.object_id)
task_comment_map[task_id] = {
"text": comment.text,
"date": fields.serialize_value(comment.created_at),
"person_id": fields.serialize_value(comment.person_id)
}
for task in tasks:
if task["id"] in task_comment_map:
task["last_comment"] = task_comment_map[task["id"]]
else:
task["last_comment"] = {}
return tasks
def get_person_tasks(person_id, projects, is_done=None):
"""
Retrieve all tasks for given person and projects.
"""
person = Person.get(person_id)
project_ids = [project["id"] for project in projects]
Sequence = aliased(Entity, name="sequence")
Episode = aliased(Entity, name="episode")
query = (
Task.query.join(Project, TaskType, TaskStatus)
.join(Entity, Entity.id == Task.entity_id)
.join(EntityType, EntityType.id == Entity.entity_type_id)
.outerjoin(Sequence, Sequence.id == Entity.parent_id)
.outerjoin(Episode, Episode.id == Sequence.parent_id)
.filter(Task.assignees.contains(person))
.filter(Project.id.in_(project_ids))
.add_columns(
Project.name,
Project.has_avatar,
Entity.id,
Entity.name,
Entity.description,
Entity.preview_file_id,
Entity.source_id,
EntityType.name,
Sequence.name,
Episode.id,
Episode.name,
TaskType.name,
TaskStatus.name,
TaskType.color,
TaskStatus.color,
TaskStatus.short_name,
)
)
if is_done:
query = query.filter(TaskStatus.is_done == True).order_by(
Task.end_date.desc(), TaskType.name, Entity.name
)
else:
query = query.filter(TaskStatus.is_done == False)
tasks = []
for (
task,
project_name,
project_has_avatar,
entity_id,
entity_name,
entity_description,
entity_preview_file_id,
entity_source_id,
entity_type_name,
sequence_name,
episode_id,
episode_name,
task_type_name,
task_status_name,
task_type_color,
task_status_color,
task_status_short_name,
) in query.all():
if entity_preview_file_id is None:
entity_preview_file_id = ""
if entity_source_id is None:
entity_source_id = ""
if episode_id is None:
episode_id = entity_source_id
task_dict = task.serialize(relations=True)
task_dict.update(
{
"project_name": project_name,
"project_id": str(task.project_id),
"project_has_avatar": project_has_avatar,
"entity_id": str(entity_id),
"entity_name": entity_name,
"entity_description": entity_description,
"entity_preview_file_id": str(entity_preview_file_id),
"entity_source_id": str(entity_source_id),
"entity_type_name": entity_type_name,
"sequence_name": sequence_name,
"episode_id": str(episode_id),
"episode_name": episode_name,
"task_estimation": task.estimation,
"task_duration": task.duration,
"task_due_date": fields.serialize_value(task.due_date),
"task_type_name": task_type_name,
"task_status_name": task_status_name,
"task_type_color": task_type_color,
"task_status_color": task_status_color,
"task_status_short_name": task_status_short_name,
}
)
tasks.append(task_dict)
task_ids = [task["id"] for task in tasks]
task_comment_map = {}
comments = (
Comment.query.filter(Comment.object_id.in_(task_ids))
.join(Person)
.filter(Person.role != "client")
.order_by(Comment.object_id, Comment.created_at)
.all()
)
task_id = None
for comment in comments:
if comment.object_id != task_id:
task_id = fields.serialize_value(comment.object_id)
task_comment_map[task_id] = {
"text": comment.text,
"date": fields.serialize_value(comment.created_at),
"person_id": fields.serialize_value(comment.person_id),
}
for task in tasks:
if task["id"] in task_comment_map:
task["last_comment"] = task_comment_map[task["id"]]
else:
task["last_comment"] = {}
return tasks
def assign_user(self, task_id):
tasks_service.assign_task(task_id, self.user_id)
project = Project.get(self.project_id)
person = Person.get(self.user_id)
project.team.append(person)
project.save()
