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()