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 remove_task(task_id, force=False): """ Remove given task. Force deletion if the task has some comments and files related. This will lead to the deletion of all of them. """ task = Task.get(task_id) if force: working_files = WorkingFile.query.filter_by(task_id=task_id) for working_file in working_files: output_files = OutputFile.query.filter_by( source_file_id=working_file.id ) for output_file in output_files: output_file.delete() working_file.delete() comments = Comment.query.filter_by(object_id=task_id) for comment in comments: notifications = Notification.query.filter_by(comment_id=comment.id) for notification in notifications: notification.delete() news_list = News.query.filter_by(comment_id=comment.id) for news in news_list: news.delete() comment.delete() subscriptions = Subscription.query.filter_by(task_id=task_id) for subscription in subscriptions: subscription.delete() preview_files = PreviewFile.query.filter_by(task_id=task_id) for preview_file in preview_files: remove_preview_file(preview_file) time_spents = TimeSpent.query.filter_by(task_id=task_id) for time_spent in time_spents: time_spent.delete() notifications = Notification.query.filter_by(task_id=task_id) for notification in notifications: notification.delete() news_list = News.query.filter_by(task_id=task.id) for news in news_list: news.delete() task.delete() events.emit("task:delete", {"task_id": task_id}) return task.serialize()
def reset_task_data(task_id): task = Task.get(task_id) retake_count = 0 real_start_date = None last_comment_date = None end_date = None task_status_id = TaskStatus.get_by(short_name="todo").id comments = (Comment.query.join(TaskStatus).filter( Comment.object_id == task_id).order_by(Comment.created_at).add_columns( TaskStatus.is_retake, TaskStatus.is_done, TaskStatus.short_name).all()) previous_is_retake = False for ( comment, task_status_is_retake, task_status_is_done, task_status_short_name, ) in comments: if task_status_is_retake and not previous_is_retake: retake_count += 1 previous_is_retake = task_status_is_retake if task_status_short_name.lower() == "wip" and real_start_date is None: real_start_date = comment.created_at if task_status_is_done: end_date = comment.created_at else: end_date = None task_status_id = comment.task_status_id last_comment_date = comment.created_at duration = 0 time_spents = TimeSpent.get_all_by(task_id=task.id) for time_spent in time_spents: duration += time_spent.duration task.update({ "duration": duration, "retake_count": retake_count, "real_start_date": real_start_date, "last_comment_date": last_comment_date, "end_date": end_date, "task_status_id": task_status_id, }) events.emit("task:update", {"task_id": task.id}) return task.serialize()
def create_or_update_time_spent(task_id, person_id, date, duration, add=False): """ Create a new time spent if it doesn't exist. If it exists, it update it with the new duratin and returns it from the database. """ try: time_spent = TimeSpent.get_by( task_id=task_id, person_id=person_id, date=date ) except DataError: raise WrongDateFormatException task = Task.get(task_id) project_id = str(task.project_id) if time_spent is not None: if duration == 0: time_spent.delete() elif add: time_spent.update({"duration": time_spent.duration + duration}) else: time_spent.update({"duration": duration}) events.emit( "time-spent:update", {"time_spent_id": str(time_spent.id)}, project_id=project_id ) else: time_spent = TimeSpent.create( task_id=task_id, person_id=person_id, date=date, duration=duration ) events.emit( "time-spent:new", {"time_spent_id": str(time_spent.id)}, project_id=project_id ) task.duration = 0 time_spents = TimeSpent.get_all_by(task_id=task_id) for time_spent in time_spents: task.duration += time_spent.duration task.save() clear_task_cache(task_id) events.emit( "task:update", {"task_id": task_id}, project_id=project_id ) return time_spent.serialize()
def test_serialize_orm_array(self): person = Person(id=uuid.uuid4(), first_name="Jhon", last_name="Doe") person2 = Person(id=uuid.uuid4(), first_name="Emma", last_name="Peel") task = Task(id=uuid.uuid4(), name="Test Task", assignees=[person, person2]) is_id = str(person.id) in fields.serialize_orm_arrays(task.assignees) self.assertTrue(is_id) is_id = str(person2.id) in fields.serialize_orm_arrays(task.assignees) self.assertTrue(is_id) is_id = str(person.id) in fields.serialize_value(task.assignees) self.assertTrue(is_id) is_id = str(person2.id) in fields.serialize_value(task.assignees) self.assertTrue(is_id)
def test_status_to_wip(self): events.register( "task:start", "mark_event_as_fired", self ) now = datetime.datetime.now() self.task.update({"real_start_date": None}) tasks_service.start_task(self.task.id) task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.wip_status_id) self.assertGreater(task.real_start_date.isoformat(), now.isoformat()) self.assert_event_is_fired()
def test_get_preview_files_for_vendor(self): """ Test route data/preview-files for vendor. The vendor can only access the tasks he's working on. """ route = "data/preview-files" self.log_in_vendor() preview_files_vendor = self.get(route) for preview_file in preview_files_vendor: # tasks_service.get_task doesn't contain assignees, thus we use Task class task = Task.get(preview_file["task_id"]) assignees_ids = [str(assignee.id) for assignee in task.assignees] self.assertIn(self.user_vendor_id, assignees_ids) self.assertEqual(len(preview_files_vendor), 3)
def test_get_preview_file_for_vendor(self): """ Test route data/preview-files/<preview_file_id> for vendor. The vendor can only access the tasks he's working on. """ route2_1 = "data/preview-files/%s" % str(self.preview_file2_1.id) route2_2 = "data/preview-files/%s" % str(self.preview_file2_2.id) self.log_in_vendor() preview_file_vendor = self.get(route2_2) # tasks_service.get_task doesn't contain assignees, thus we use Task class task = Task.get(preview_file_vendor["task_id"]) assignees_ids = [str(assignee.id) for assignee in task.assignees] self.assertIn(self.user_vendor_id, assignees_ids) self.get(route2_1, code=403)
def create_task(task_type, entity, name="main"): """ Create a new task for given task type and entity. """ task_status = get_todo_status() try: try: current_user_id = persons_service.get_current_user()["id"] except RuntimeError: current_user_id = None task = Task.create( name=name, duration=0, estimation=0, completion_rate=0, start_date=None, end_date=None, due_date=None, real_start_date=None, project_id=entity["project_id"], task_type_id=task_type["id"], task_status_id=task_status["id"], entity_id=entity["id"], assigner_id=current_user_id, assignees=[], ) task_dict = task.serialize(relations=True) task_dict.update( { "task_status_id": task_status["id"], "task_status_name": task_status["name"], "task_status_short_name": task_status["short_name"], "task_status_color": task_status["color"], "task_type_id": task_type["id"], "task_type_name": task_type["name"], "task_type_color": task_type["color"], "task_type_priority": task_type["priority"], } ) events.emit( "task:new", {"task_id": task.id}, project_id=entity["project_id"] ) return task_dict except IntegrityError: pass # Tasks already exists, no need to create it.
def generate_fixture_task_standard(self): start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.task_standard = Task.create(name="Super modeling", project_id=self.project_standard.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=self.asset_standard.id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date)
def generate_fixture_edit_task(self, name="Edit", task_type_id=None): if task_type_id is None: task_type_id = self.task_type_edit.id self.edit_task = Task.create( name=name, project_id=self.project.id, task_type_id=task_type_id, task_status_id=self.task_status.id, entity_id=self.edit.id, assignees=[self.person], assigner_id=self.assigner.id, ) self.project.team.append(self.person) self.project.save() return self.edit_task
def test_import_version(self): sg_version = { "code": "S01_Animation", "description": "description test", "id": 2, "user": {"id": 1, "name": "Jhon Doe", "type": "HumanUser"}, "entity": {"id": 1, "name": "SH01", "type": "Shot"}, "project": {"id": 1, "name": "Cosmos Landromat", "type": "Project"}, "sg_task": {"id": 1, "name": "Animation", "type": "Task"}, "sg_uploaded_movie": { "content_type": "video/mp4", "id": 1, "link_type": "upload", "name": "movie_new.mp4", "type": "Attachment", "url": "https://sg-media.amazonaws.com/9e73/movie_new.mp4", }, "type": "Version", } api_path = "/import/shotgun/versions" self.preview_files = self.post(api_path, [sg_version], 200) self.assertEqual(len(self.preview_files), 1) self.preview_files = self.get("data/preview-files") self.assertEqual(len(self.preview_files), 1) preview_file = self.preview_files[0] task = Task.get_by(shotgun_id=sg_version["sg_task"]["id"]) person = Person.get_by(shotgun_id=sg_version["user"]["id"]) self.assertEqual(preview_file["name"], sg_version["code"]) self.assertEqual(preview_file["source"], "Shotgun") self.assertEqual(preview_file["task_id"], str(task.id)) self.assertEqual(preview_file["name"], sg_version["code"]) self.assertEqual(preview_file["description"], sg_version["description"]) self.assertEqual(preview_file["shotgun_id"], sg_version["id"]) self.assertEqual( preview_file["uploaded_movie_url"], sg_version["sg_uploaded_movie"]["url"], ) self.assertEqual( preview_file["uploaded_movie_url"], sg_version["sg_uploaded_movie"]["url"], ) self.assertEqual(preview_file["person_id"], str(person.id))
def create_new_working_revision( person_id, software_id, entity_id=None, task_id=None, name="main", path="", comment="", revision=0, ): """ Create a new working file revision for given task. An author (user) and a software are required. """ if task_id: task = Task.get(task_id) entity_id = task.entity_id if revision == 0: revision = get_next_working_revision(name, task_id=task_id, entity_id=entity_id) if path: previous_working_file = get_working_file_by_path(path) if previous_working_file: return previous_working_file.serialize() try: working_file = WorkingFile.create( comment=comment, name=name, revision=revision, path=path, task_id=task_id, software_id=software_id, entity_id=entity_id, person_id=person_id, ) events.emit( "working_file:new", {"working_file_id": working_file.id}, project_id=str(task.project_id) ) except IntegrityError: raise EntryAlreadyExistsException return working_file.serialize()
def test_publish_task(self): handler = ToReviewHandler(self.open_status_id, self.to_review_status_id) events.register("task:to-review", "mark_event_as_fired", handler) tasks_service.task_to_review(self.task.id, self.person.serialize(), "my comment") self.is_event_fired = handler.is_event_fired data = handler.data task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.to_review_status_id) self.assert_event_is_fired() self.assertEquals(data["previous_task_status_id"], str(self.open_status_id)) self.assertEquals(data["comment"], "my comment")
def update_preview_file(preview_file_id, data, silent=False): try: preview_file = files_service.get_preview_file_raw(preview_file_id) except: # Dirty hack because sometimes the preview file retrieval crashes. time.sleep(1) preview_file = files_service.get_preview_file_raw(preview_file_id) preview_file.update(data) files_service.clear_preview_file_cache(preview_file_id) if not silent: task = Task.get(preview_file.task_id) events.emit( "preview-file:update", {"preview_file_id": preview_file_id}, project_id=str(task.project_id), ) return preview_file.serialize()
def guess_task(entity, task_type, task_name): if entity is None: raise WrongPathFormatException( "No asset or shot found in given path." ) criterions = { "entity_id": entity.id, "task_type_id": task_type.id } if len(task_name) > 0: criterions["name"] = task_name task = Task.get_by(**criterions) if task is None: raise TaskNotFoundException else: return task
def test_import_note(self): self.load_note() self.assertEqual(len(self.notes), 1) self.comments = self.get("data/comments") self.assertEqual(len(self.comments), 1) note = self.comments[0] task = Task.get_by(shotgun_id=self.sg_note["tasks"][0]["id"]) person = Person.get_by(shotgun_id=self.sg_note["user"]["id"]) self.assertEqual(note["text"], self.sg_note["content"]) self.assertEqual(note["object_type"], "Task") self.assertEqual(note["shotgun_id"], self.sg_note["id"]) self.assertEqual(note["object_id"], str(task.id)) self.assertEqual(note["person_id"], str(person.id)) self.assertEqual(note["created_at"][:19], self.sg_note["created_at"][:19])
def import_entry(self, data): task = Task.get_by(shotgun_id=data["shotgun_id"]) if task is None: task = Task.get_by( name=data["name"], project_id=data["project_id"], task_type_id=data["task_type_id"], entity_id=data["entity_id"] ) if task is None: task = Task(**data) task.save() current_app.logger.info("Task created: %s" % task) else: task.update(data) current_app.logger.info("Task updated: %s" % task) return task
def generate_fixture_task(self, name="Master", asset_id=None): if asset_id is None: asset_id = self.asset.id start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.task = Task.create(name=name, project_id=self.project.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=asset_id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date) return self.task
def remove_preview_file(preview_file): """ Remove all files related to given preview file, then remove the preview file entry from the database. """ task = Task.get(preview_file.task_id) entity = Entity.get(task.entity_id) if entity.preview_file_id == preview_file.id: entity.update({"preview_file_id": None}) if preview_file.extension == "png": clear_picture_files(preview_file.id) elif preview_file.extension == "mp4": clear_movie_files(preview_file.id) else: clear_generic_files(preview_file.id) preview_file.comments = [] preview_file.save() preview_file.delete() return preview_file.serialize()
def refresh_shot_casting_stats(shot, priority_map=None): """ For all tasks related to given shot, it computes how many assets are available for this task and saves the result on the task level. """ if priority_map is None: priority_map = _get_task_type_priority_map(shot["project_id"]) casting = get_entity_casting(shot["id"]) tasks = Task.get_all_by(entity_id=shot["id"]) for task in tasks: nb_ready = 0 for asset in casting: if _is_asset_ready(asset, task, priority_map): nb_ready += 1 task.update({"nb_assets_ready": nb_ready}) events.emit("task:update-casting-stats", { "task_id": str(task.id), "nb_assets_ready": nb_ready }, persist=False, project_id=shot["project_id"])
def add_preview_file_to_comment(comment_id, person_id, task_id, revision=0): """ Add a preview to comment preview list. Auto set the revision field (add 1 if it's a new preview, keep the preview revision in other cases). """ comment = get_comment_raw(comment_id) news = News.get_by(comment_id=comment_id) task = Task.get(comment.object_id) project_id = str(task.project_id) position = 1 if revision == 0 and len(comment.previews) == 0: revision = get_next_preview_revision(task_id) elif revision == 0: revision = comment.previews[0].revision position = get_next_position(task_id, revision) else: position = get_next_position(task_id, revision) preview_file = files_service.create_preview_file_raw(str( uuid.uuid4())[:13], revision, task_id, person_id, position=position) events.emit( "preview-file:new", { "preview_file_id": preview_file.id, "comment_id": comment_id, }, project_id=project_id, ) comment.previews.append(preview_file) comment.save() if news is not None: news.update({"preview_file_id": preview_file.id}) events.emit("comment:update", {"comment_id": comment.id}, project_id=project_id) return preview_file.serialize()
def remove_task(task_id, force=False): """ Remove given task. Force deletion if the task has some comments and files related. This will lead to the deletion of all of them. """ task = Task.get(task_id) entity = Entity.get(task.entity_id) if force: working_files = WorkingFile.query.filter_by(task_id=task_id) for working_file in working_files: output_files = OutputFile.query.filter_by( source_file_id=working_file.id) for output_file in output_files: output_file.delete() working_file.delete() comments = Comment.query.filter_by(object_id=task_id) for comment in comments: notifications = Notification.query.filter_by(comment_id=comment.id) for notification in notifications: notification.delete() comment.delete() subscriptions = Subscription.query.filter_by(task_id=task_id) for subscription in subscriptions: subscription.delete() preview_files = PreviewFile.query.filter_by(task_id=task_id) for preview_file in preview_files: if entity.preview_file_id == preview_file.id: entity.update({"preview_file_id": None}) remove_preview_file(preview_file) task.delete() events.emit("task:deletion", {"task_id": task_id}) return task.serialize()
def remove_comment(comment_id): """ Remove a comment from database and everything related (notifs, news, and preview files) """ comment = Comment.get(comment_id) if comment is not None: task = Task.get(comment.object_id) notifications = Notification.query.filter_by(comment_id=comment.id) for notification in notifications: notification.delete() news_list = News.query.filter_by(comment_id=comment.id) for news in news_list: news.delete() if comment.preview_file_id is not None: preview_file = PreviewFile.get(comment.preview_file_id) comment.preview_file_id = None comment.save() remove_preview_file(preview_file) previews = [preview for preview in comment.previews] comment.delete() for preview in previews: remove_preview_file(preview) if task is not None: events.emit( "comment:delete", {"comment_id": comment.id}, project_id=str(task.project_id), ) return comment.serialize() else: raise CommentNotFoundException
class TaskServiceTestCase(ApiDBTestCase): def setUp(self): super(TaskServiceTestCase, self).setUp() self.generate_fixture_project_status() self.generate_fixture_project() self.generate_fixture_asset_type() self.generate_fixture_asset() self.generate_fixture_sequence() self.generate_fixture_shot() self.generate_fixture_department() self.generate_fixture_task_type() self.generate_fixture_task_status() self.generate_fixture_task_status_wip() self.generate_fixture_task_status_to_review() self.generate_fixture_person() self.generate_fixture_assigner() self.generate_fixture_task() self.generate_fixture_shot_task() self.generate_fixture_file_status() self.generate_fixture_software() self.generate_fixture_working_file() self.generate_fixture_output_type() self.generate_fixture_output_file() self.task_id = self.task.id self.open_status_id = self.task_status.id self.wip_status_id = self.task_status_wip.id self.to_review_status_id = self.task_status_to_review.id self.is_event_fired = False events.unregister_all() def handle_event(self, data): self.is_event_fired = True self.assertEqual(data["previous_task_status_id"], str(self.open_status_id)) def assert_event_is_fired(self): self.assertTrue(self.is_event_fired) def test_get_status(self): task_status = tasks_service.get_or_create_status("WIP", "wip") self.assertEqual(task_status["name"], "WIP") def test_get_wip_status(self): task_status = tasks_service.get_wip_status() self.assertEqual(task_status["name"], "WIP") def test_get_done_status(self): task_status = tasks_service.get_done_status() self.assertEqual(task_status["name"], "Done") def test_get_todo_status(self): task_status = tasks_service.get_todo_status() self.assertEqual(task_status["name"], "Todo") def test_get_to_review_status(self): task_status = tasks_service.get_to_review_status() self.assertEqual(task_status["name"], "To review") def test_create_task(self): shot = self.shot.serialize() task_type = self.task_type.serialize() status = tasks_service.get_todo_status() task = tasks_service.create_task(task_type, shot) task = tasks_service.get_task(task["id"]) self.assertEquals(task["entity_id"], shot["id"]) self.assertEquals(task["task_type_id"], task_type["id"]) self.assertEquals(task["project_id"], shot["project_id"]) self.assertEquals(task["task_status_id"], status["id"]) def test_status_to_wip(self): events.register("task:start", "mark_event_as_fired", self) now = datetime.datetime.now() self.task.update({"real_start_date": None}) tasks_service.start_task(self.task.id) task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.wip_status_id) self.assertGreater(task.real_start_date.isoformat(), now.isoformat()) self.assert_event_is_fired() def test_status_to_wip_twice(self): tasks_service.start_task(self.task.id) task = Task.get(self.task.id) real_start_date = task.real_start_date task.update({"task_status_id": self.task_status.id}) tasks_service.start_task(self.task.id) task = Task.get(self.task.id) self.assertEqual(task.real_start_date, real_start_date) def test_publish_task(self): handler = ToReviewHandler(self.open_status_id, self.to_review_status_id) events.register("task:to-review", "mark_event_as_fired", handler) tasks_service.task_to_review(self.task.id, self.person.serialize(), "my comment") self.is_event_fired = handler.is_event_fired data = handler.data task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.to_review_status_id) self.assert_event_is_fired() self.assertEquals(data["previous_task_status_id"], str(self.open_status_id)) self.assertEquals(data["comment"], "my comment") def test_assign_task(self): tasks_service.assign_task(self.task.id, self.assigner.id) self.assertEqual(self.task.assignees[1].id, self.assigner.id) def test_get_department_from_task(self): department = tasks_service.get_department_from_task(self.task.id) self.assertEqual(department["name"], "Modeling") def test_get_task(self): self.assertRaises(TaskNotFoundException, tasks_service.get_task, "wrong-id") task = tasks_service.get_task(self.task_id) self.assertEqual(str(self.task_id), task["id"]) self.output_file.delete() self.working_file.delete() tasks_service.remove_task(task["id"]) self.assertRaises(TaskNotFoundException, tasks_service.get_task, self.task_id) def test_get_tasks_for_sequence(self): self.generate_fixture_sequence_task() tasks = tasks_service.get_tasks_for_sequence(self.sequence.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.sequence_task.id)) def test_get_tasks_for_shot(self): tasks = tasks_service.get_tasks_for_shot(self.shot.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.shot_task.id)) def test_get_tasks_for_scene(self): self.generate_fixture_scene() self.generate_fixture_scene_task() tasks = tasks_service.get_tasks_for_scene(self.scene.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.scene_task.id)) def test_get_dict_tasks_for_asset(self): tasks = tasks_service.get_task_dicts_for_entity(self.asset.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.task.id)) self.assertEqual(tasks[0]["task_type_name"], str("Shaders")) self.assertEqual(tasks[0]["entity_name"], str("Tree")) def test_get_task_types_for_shot(self): task_types = tasks_service.get_task_types_for_shot(self.shot.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_scene(self): self.generate_fixture_scene() self.generate_fixture_scene_task() task_types = tasks_service.get_task_types_for_scene(self.scene.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_sequence(self): self.generate_fixture_sequence_task() task_types = tasks_service.get_task_types_for_sequence( self.sequence.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_entity(self): task_types = tasks_service.get_task_types_for_entity(self.asset.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type.id)) def test_get_task_dicts_for_entity_utf8(self): start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.working_file.delete() self.output_file.delete() self.task.delete() self.task_type = TaskType(name="Modélisation", color="#FFFFFF", department_id=self.department.id) self.task_type.save() self.task = Task(name="Première Tâche", project_id=self.project.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=self.asset.id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date) self.task.save() tasks = tasks_service.get_task_dicts_for_entity(self.asset.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["name"], u"Première Tâche") self.assertEqual(tasks[0]["task_type_name"], u"Modélisation") def test_get_or_create_time_spents(self): person_id = self.person.id task_id = self.task.id duration = 3600 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration) self.assertEquals(time_spent["duration"], duration) duration = 7200 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration) self.assertEquals(time_spent["duration"], duration) duration = 7200 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration, add=True) self.assertEquals(time_spent["duration"], 2 * duration) def test_get_time_spents(self): person_id = self.person.id user_id = self.user.id task_id = self.task.id TimeSpent.create(person_id=person_id, task_id=task_id, date=datetime.date(2017, 9, 23), duration=3600) TimeSpent.create(person_id=user_id, task_id=task_id, date=datetime.date(2017, 9, 23), duration=7200) time_spents = self.get("/actions/tasks/%s/time-spents/2017-09-23/" % task_id) self.assertEquals(time_spents["total"], 10800) self.assertEquals(time_spents[str(user_id)]["duration"], 7200) self.assertEquals(time_spents[str(person_id)]["duration"], 3600) def test_clear_assignation(self): task_id = self.task.id tasks_service.assign_task(self.task.id, self.person.id) tasks_service.clear_assignation(task_id) task = tasks_service.get_task(task_id) self.assertEquals(len(task["assignees"]), 0) def test_get_tasks_for_person(self): projects = [self.project.serialize()] tasks = tasks_service.get_person_tasks(self.user.id, projects) self.assertEqual(len(tasks), 0) tasks_service.assign_task(self.task.id, self.user.id) tasks = tasks_service.get_person_tasks(self.user.id, projects) self.assertEqual(len(tasks), 1) tasks_service.create_comment(self.task.id, self.task_status.id, self.person.id, "first comment") tasks_service.create_comment(self.task.id, self.task_status.id, self.person.id, "last comment") tasks = tasks_service.get_person_tasks(self.person.id, projects) self.assertEqual(len(tasks), 2) self.assertEqual(tasks[1]["last_comment"]["text"], "last comment") self.assertEqual(tasks[1]["last_comment"]["person_id"], str(self.person.id)) def test_get_done_tasks_for_person(self): projects = [self.project.serialize()] tasks = tasks_service.get_person_done_tasks(self.user.id, projects) self.assertEqual(len(tasks), 0) tasks_service.assign_task(self.task.id, self.user.id) tasks = tasks_service.get_person_done_tasks(self.user.id, projects) self.assertEqual(len(tasks), 0) done_status = tasks_service.get_done_status() tasks_service.update_task(self.task.id, {"task_status_id": done_status["id"]}) tasks = tasks_service.get_person_done_tasks(self.user.id, projects) self.assertEqual(len(tasks), 1) def test_update_task(self): done_status = tasks_service.get_done_status() tasks_service.update_task(self.task.id, {"task_status_id": done_status["id"]}) self.assertEquals(str(self.task.task_status_id), done_status["id"]) self.assertIsNotNone(self.task.end_date) self.assertLess(self.task.end_date, datetime.datetime.now()) def test_remove_task(self): self.working_file.delete() self.output_file.delete() tasks_service.remove_task(self.task_id) self.assertRaises(TaskNotFoundException, tasks_service.get_task, self.task_id) def test_remove_task_force(self): tasks_service.create_comment(self.task.id, self.task_status.id, self.person.id, "first comment") tasks_service.remove_task(self.task_id, force=True) self.assertRaises(TaskNotFoundException, tasks_service.get_task, self.task_id)
def is_note_linked_to_task(self, sg_note): if len(sg_note["tasks"]) == 0: return False task = Task.get_by(shotgun_id=sg_note["tasks"][0]["id"]) return task is not None
class TaskServiceTestCase(ApiDBTestCase): def setUp(self): super(TaskServiceTestCase, self).setUp() self.generate_fixture_project_status() self.generate_fixture_project() self.generate_fixture_asset_type() self.generate_fixture_asset() self.generate_fixture_sequence() self.generate_fixture_shot() self.generate_fixture_department() self.generate_fixture_task_type() self.generate_fixture_task_status() self.generate_fixture_task_status_wip() self.generate_fixture_task_status_to_review() self.generate_fixture_person() self.generate_fixture_assigner() self.generate_fixture_task() self.generate_fixture_shot_task() self.generate_fixture_file_status() self.generate_fixture_software() self.generate_fixture_working_file() self.generate_fixture_output_type() self.generate_fixture_output_file() self.project_id = str(self.project.id) self.task_id = str(self.task.id) self.open_status_id = self.task_status.id self.wip_status_id = self.task_status_wip.id self.to_review_status_id = self.task_status_to_review.id self.is_event_fired = False events.unregister_all() def handle_event(self, data): self.is_event_fired = True self.assertEqual( data["previous_task_status_id"], str(self.open_status_id) ) def assert_event_is_fired(self): self.assertTrue(self.is_event_fired) def test_get_status(self): task_status = tasks_service.get_or_create_status("WIP", "wip") self.assertEqual(task_status["name"], "WIP") def test_get_wip_status(self): task_status = tasks_service.get_wip_status() self.assertEqual(task_status["name"], "WIP") def test_get_done_status(self): task_status = tasks_service.get_done_status() self.assertEqual(task_status["name"], "Done") def test_get_todo_status(self): task_status = tasks_service.get_todo_status() self.assertEqual(task_status["name"], "Todo") def test_get_to_review_status(self): task_status = tasks_service.get_to_review_status() self.assertEqual(task_status["name"], "To review") def test_create_task(self): shot = self.shot.serialize() task_type = self.task_type.serialize() status = tasks_service.get_todo_status() task = tasks_service.create_task(task_type, shot) task = tasks_service.get_task(task["id"]) self.assertEqual(task["entity_id"], shot["id"]) self.assertEqual(task["task_type_id"], task_type["id"]) self.assertEqual(task["project_id"], shot["project_id"]) self.assertEqual(task["task_status_id"], status["id"]) def test_create_tasks(self): shot = self.shot.serialize() shot_2 = self.generate_fixture_shot("S02").serialize() task_type = self.task_type.serialize() status = tasks_service.get_todo_status() tasks = tasks_service.create_tasks(task_type, [shot, shot_2]) self.assertEqual(len(tasks), 2) task = tasks[0] task = tasks_service.get_task(task["id"]) self.assertEqual(task["entity_id"], shot["id"]) self.assertEqual(task["task_type_id"], task_type["id"]) self.assertEqual(task["project_id"], shot["project_id"]) self.assertEqual(task["task_status_id"], status["id"]) def test_status_to_wip(self): events.register("task:start", "mark_event_as_fired", self) now = datetime.datetime.now() self.task.update({"real_start_date": None}) tasks_service.start_task(self.task.id) task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.wip_status_id) self.assertGreater(task.real_start_date.isoformat(), now.isoformat()) self.assert_event_is_fired() def test_status_to_wip_twice(self): tasks_service.start_task(self.task.id) task = Task.get(self.task.id) real_start_date = task.real_start_date task.update({"task_status_id": self.task_status.id}) tasks_service.start_task(self.task.id) task = Task.get(self.task.id) self.assertEqual(task.real_start_date, real_start_date) def test_publish_task(self): handler = ToReviewHandler( self.open_status_id, self.to_review_status_id ) events.register("task:to-review", "mark_event_as_fired", handler) tasks_service.task_to_review( self.task.id, self.person.serialize(), "my comment" ) self.is_event_fired = handler.is_event_fired data = handler.data task = Task.get(self.task.id) self.assertEqual(task.task_status_id, self.to_review_status_id) self.assert_event_is_fired() self.assertEqual( data["previous_task_status_id"], str(self.open_status_id) ) self.assertEqual(data["comment"], "my comment") def test_assign_task(self): tasks_service.assign_task(self.task.id, self.assigner.id) self.assertEqual(self.task.assignees[1].id, self.assigner.id) def test_get_department_from_task(self): department = tasks_service.get_department_from_task(self.task.id) self.assertEqual(department["name"], "Modeling") def test_get_task(self): self.assertRaises( TaskNotFoundException, tasks_service.get_task, "wrong-id" ) task = tasks_service.get_task(self.task_id) self.assertEqual(str(self.task_id), task["id"]) self.output_file.delete() self.working_file.delete() deletion_service.remove_task(task["id"]) self.assertRaises( TaskNotFoundException, tasks_service.get_task, str(self.task_id) ) def test_get_tasks_for_sequence(self): self.generate_fixture_sequence_task() tasks = tasks_service.get_tasks_for_sequence(self.sequence.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.sequence_task.id)) def test_get_tasks_for_shot(self): tasks = tasks_service.get_tasks_for_shot(self.shot.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.shot_task.id)) def test_get_tasks_for_scene(self): self.generate_fixture_scene() self.generate_fixture_scene_task() tasks = tasks_service.get_tasks_for_scene(self.scene.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.scene_task.id)) def test_get_dict_tasks_for_asset(self): tasks = tasks_service.get_task_dicts_for_entity(self.asset.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["id"], str(self.task.id)) self.assertEqual(tasks[0]["task_type_name"], str("Shaders")) self.assertEqual(tasks[0]["entity_name"], str("Tree")) def test_get_task_types_for_shot(self): task_types = tasks_service.get_task_types_for_shot(self.shot.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_scene(self): self.generate_fixture_scene() self.generate_fixture_scene_task() task_types = tasks_service.get_task_types_for_scene(self.scene.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_sequence(self): self.generate_fixture_sequence_task() task_types = tasks_service.get_task_types_for_sequence( self.sequence.id ) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id)) def test_get_task_types_for_entity(self): task_types = tasks_service.get_task_types_for_entity(self.asset.id) self.assertEqual(len(task_types), 1) self.assertEqual(task_types[0]["id"], str(self.task_type.id)) def test_get_task_dicts_for_entity_utf8(self): start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.working_file.delete() self.output_file.delete() self.task.delete() self.task_type = TaskType( name="Modélisation", color="#FFFFFF", department_id=self.department.id, ) self.task_type.save() self.task = Task( name="Première Tâche", project_id=self.project.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=self.asset.id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date, ) self.task.save() tasks = tasks_service.get_task_dicts_for_entity(self.asset.id) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0]["name"], u"Première Tâche") self.assertEqual(tasks[0]["task_type_name"], u"Modélisation") def test_get_or_create_time_spents(self): person_id = self.person.id task_id = self.task.id duration = 3600 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration, ) self.assertEqual(time_spent["duration"], duration) duration = 7200 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration, ) self.assertEqual(time_spent["duration"], duration) duration = 7200 time_spent = tasks_service.create_or_update_time_spent( person_id=person_id, task_id=task_id, date="2017-09-23", duration=duration, add=True, ) self.assertEqual(time_spent["duration"], 2 * duration) def test_get_time_spents(self): pass """ person_id = self.person.id user_id = self.user["id"] task_id = self.task.id ts1 = TimeSpent.create( person_id=person_id, task_id=task_id, date=datetime.date(2017, 9, 23), duration=3600 ) ts2 = TimeSpent.create( person_id=user_id, task_id=task_id, date=datetime.date(2017, 9, 23), duration=7200 ) ts3 = TimeSpent.create( person_id=user_id, task_id=task_id, date=datetime.date(2017, 9, 24), duration=7200 ) time_spents = self.get( "/data/time-spents?task_id=%s" % task_id ) self.assertEqual( time_spents["total"], sum([ts.duration for ts in [ts1, ts2, ts3]])) self.assertEqual(len(time_spents[str(user_id)]), 1) self.assertEqual(len(time_spents[str(person_id)]), 2) """ def test_clear_assignation(self): task_id = self.task.id tasks_service.assign_task(self.task.id, self.person.id) tasks_service.clear_assignation(task_id) task = tasks_service.get_task_with_relations(task_id) self.assertEqual(len(task["assignees"]), 0) def test_get_tasks_for_person(self): projects = [self.project.serialize()] tasks = tasks_service.get_person_tasks(self.user["id"], projects) self.assertEqual(len(tasks), 0) tasks_service.assign_task(self.task.id, self.user["id"]) tasks = tasks_service.get_person_tasks(self.user["id"], projects) self.assertEqual(len(tasks), 1) comments_service.new_comment( self.task.id, self.task_status.id, self.person.id, "first comment" ) comments_service.new_comment( self.task.id, self.task_status.id, self.person.id, "last comment" ) tasks = tasks_service.get_person_tasks(self.person.id, projects) self.assertEqual(len(tasks), 2) self.assertEqual(tasks[1]["last_comment"]["text"], "last comment") self.assertEqual( tasks[1]["last_comment"]["person_id"], str(self.person.id) ) def test_get_done_tasks_for_person(self): projects = [self.project.serialize()] tasks = tasks_service.get_person_done_tasks(self.user["id"], projects) self.assertEqual(len(tasks), 0) tasks_service.assign_task(self.task.id, self.user["id"]) tasks = tasks_service.get_person_done_tasks(self.user["id"], projects) self.assertEqual(len(tasks), 0) done_status = tasks_service.get_done_status() tasks_service.update_task( self.task.id, {"task_status_id": done_status["id"]} ) tasks = tasks_service.get_person_done_tasks(self.user["id"], projects) self.assertEqual(len(tasks), 1) def test_update_task(self): done_status = tasks_service.get_done_status() tasks_service.update_task( self.task.id, {"task_status_id": done_status["id"]} ) self.assertEqual(str(self.task.task_status_id), done_status["id"]) self.assertIsNotNone(self.task.end_date) self.assertLess(self.task.end_date, datetime.datetime.now()) def test_remove_task(self): self.working_file.delete() self.output_file.delete() deletion_service.remove_task(self.task_id) self.assertRaises( TaskNotFoundException, tasks_service.get_task, self.task_id ) def test_remove_tasks(self): self.working_file.delete() self.output_file.delete() task_id = str(self.task_id) task2_id = str(self.generate_fixture_task("main 2").id) task_ids = [task_id, task2_id] deletion_service.remove_tasks(self.project_id, task_ids) self.assertRaises( TaskNotFoundException, tasks_service.get_task, task_id ) self.assertRaises( TaskNotFoundException, tasks_service.get_task, task2_id ) def test_remove_task_force(self): comments_service.new_comment( self.task.id, self.task_status.id, self.person.id, "first comment" ) TimeSpent.create( person_id=self.person.id, task_id=self.task.id, date=datetime.date(2017, 9, 23), duration=3600, ) deletion_service.remove_task(self.task_id, force=True) self.assertRaises( TaskNotFoundException, tasks_service.get_task, self.task_id ) def test_delete_all_task_types(self): self.generate_fixture_project_standard() self.generate_fixture_asset_standard() task_1_id = str(self.task.id) task_2_id = str(self.generate_fixture_task(name="second task").id) task_3_id = str(self.shot_task.id) task_4_id = str(self.generate_fixture_task_standard().id) deletion_service.remove_tasks_for_project_and_task_type( self.project.id, self.task_type.id ) self.assertIsNone(Task.get(task_1_id)) self.assertIsNone(Task.get(task_2_id)) self.assertIsNotNone(Task.get(task_3_id)) self.assertIsNotNone(Task.get(task_4_id)) def test_get_comment_mentions(self): mentions = comments_service.get_comment_mentions( self.task_id, "Test @Emma Doe" ) self.assertEqual(len(mentions), 0) mentions = comments_service.get_comment_mentions( self.task_id, "Test @John Doe" ) self.assertEqual(mentions[0], self.person) def test_get_comments(self): self.generate_fixture_user_client() self.generate_fixture_comment() self.generate_fixture_comment() self.generate_fixture_comment(person=self.user_client) self.generate_fixture_comment() comments = tasks_service.get_comments(self.task_id, is_manager=True) self.assertEqual(len(comments), 4) comments = tasks_service.get_comments(self.task_id, is_manager=False) self.assertEqual(len(comments), 3) comments = tasks_service.get_comments(self.task_id, is_client=True) self.assertEqual(len(comments), 1) def test_new_comment(self): comment = comments_service.new_comment( self.task_id, self.task_status.id, self.person.id, "Test @John Doe" ) self.assertEqual(comment["mentions"][0], str(self.person.id)) def test_get_full_task(self): task = tasks_service.get_full_task(self.task.id) self.assertEqual(task["project"]["name"], self.project.name) self.assertEqual(task["assigner"]["id"], str(self.assigner.id)) self.assertEqual(task["persons"][0]["id"], str(self.person.id)) self.assertEqual(task["task_status"]["id"], str(self.task_status.id)) self.assertEqual(task["task_type"]["id"], str(self.task_type.id)) task = tasks_service.get_full_task(self.shot_task.id) self.assertEqual(task["sequence"]["id"], str(self.sequence.id)) def test_get_next_position(self): self.generate_fixture_preview_file(revision=1) self.generate_fixture_preview_file(revision=2) self.generate_fixture_preview_file(revision=2, name="second") task_id = self.task.id position = tasks_service.get_next_position(task_id, 2) self.assertEqual(position, 3) def test_update_preview_file_position(self): self.generate_fixture_preview_file(revision=1) self.generate_fixture_preview_file(revision=2) preview_file = self.generate_fixture_preview_file( revision=2, name="second" ) preview_file_id = str(preview_file.id) self.generate_fixture_preview_file(revision=2, name="third") preview_files_service.update_preview_file_position(preview_file_id, 1) preview_files = PreviewFile.query.filter_by( task_id=self.task_id, revision=2 ).order_by(PreviewFile.position) for (i, preview_file) in enumerate(preview_files): self.assertEqual(preview_file.position, i + 1) self.assertEqual(str(preview_files[0].id), preview_file_id) preview_files_service.update_preview_file_position(preview_file_id, 3) preview_files = PreviewFile.query.filter_by( task_id=self.task_id, revision=2 ).order_by(PreviewFile.position) for (i, preview_file) in enumerate(preview_files): self.assertEqual(preview_file.position, i + 1) self.assertEqual(str(preview_files[2].id), preview_file_id)
class ApiDBTestCase(ApiTestCase): def setUp(self): """ Reset database before each test. """ super(ApiDBTestCase, self).setUp() from zou.app.utils import dbhelpers dbhelpers.drop_all() dbhelpers.create_all() self.log_in() def log_in(self): self.generate_fixture_user() self.post("auth/login", { "email": self.user.email, "password": "******" }, 200) def tearDown(self): """ Delete database after each test. """ from zou.app.utils import dbhelpers dbhelpers.drop_all() def generate_data(self, cls, number, **kwargs): """ Generate random data for a given data model. """ mixer.init_app(self.flask_app) return mixer.cycle(number).blend(cls, id=fields.gen_uuid, **kwargs) def generate_fixture_project_status(self): self.open_status = ProjectStatus(name="open", color="#FFFFFF") self.open_status.save() def generate_fixture_project_closed_status(self): self.closed_status = ProjectStatus(name="closed", color="#FFFFFF") self.closed_status.save() def generate_fixture_project(self): self.project = Project(name="Cosmos Landromat", project_status_id=self.open_status.id) self.project.save() self.project.update( {"file_tree": file_tree.get_tree_from_file("simple")}) def generate_fixture_project_closed(self): self.project_closed = Project(name="Old Project", project_status_id=self.closed_status.id) self.project_closed.save() def generate_fixture_project_standard(self): self.project_standard = Project(name="Big Buck Bunny", project_status_id=self.open_status.id) self.project_standard.save() self.project_standard.update( {"file_tree": file_tree.get_tree_from_file("standard")}) def generate_fixture_entity(self): self.entity = Entity(name="Tree", description="Description Tree", project_id=self.project.id, entity_type_id=self.entity_type.id) self.entity.save() def generate_fixture_entity_standard(self): self.entity_standard = Entity(name="Car", project_id=self.project_standard.id, entity_type_id=self.entity_type.id) self.entity_standard.save() def generate_fixture_sequence(self): if hasattr(self, "episode"): episode_id = self.episode.id else: episode_id = None self.sequence = Entity(name="S01", project_id=self.project.id, entity_type_id=self.sequence_type.id, parent_id=episode_id) self.sequence.save() def generate_fixture_sequence_standard(self): self.sequence_standard = Entity(name="S01", project_id=self.project_standard.id, entity_type_id=self.sequence_type.id) self.sequence_standard.save() def generate_fixture_episode(self): self.episode = Entity(name="E01", project_id=self.project.id, entity_type_id=self.episode_type.id) self.episode.save() def generate_fixture_shot(self): self.shot = Entity(name="P01", description="Description Shot 01", data={ "fps": 25, "frame_in": 0, "frame_out": 100 }, project_id=self.project.id, entity_type_id=self.shot_type.id, parent_id=self.sequence.id) self.shot.save() self.shot_noseq = Entity(name="P01NOSEQ", project_id=self.project.id, entity_type_id=self.shot_type.id) self.shot_noseq.save() def generate_fixture_shot_standard(self): self.shot_standard = Entity(name="P01", description="Description Shot 01", data={ "fps": 25, "frame_in": 0, "frame_out": 100 }, project_id=self.project_standard.id, entity_type_id=self.shot_type.id, parent_id=self.sequence_standard.id) self.shot_standard.save() def generate_fixture_user(self): self.user = Person(first_name="John", last_name="Did", email=u"*****@*****.**", password=auth.encrypt_password("mypassword")) self.user.save() def generate_fixture_person(self): self.person = Person(first_name="John", last_name="Doe", email=u"*****@*****.**", password=auth.encrypt_password("mypassword")) self.person.save() def generate_fixture_entity_type(self): self.entity_type = EntityType(name="Props") self.entity_type.save() self.shot_type = EntityType(name="Shot") self.shot_type.save() self.sequence_type = EntityType(name="Sequence") self.sequence_type.save() self.episode_type = EntityType(name="Episode") self.episode_type.save() def generate_fixture_department(self): self.department = Department(name="Modeling", color="#FFFFFF") self.department.save() self.department_animation = Department(name="Animation", color="#FFFFFF") self.department_animation.save() def generate_fixture_task_type(self): self.task_type = TaskType(name="Shaders", color="#FFFFFF", department_id=self.department.id) self.task_type.save() self.task_type_animation = TaskType( name="Animation", color="#FFFFFF", department_id=self.department_animation.id) self.task_type_animation.save() def generate_fixture_task_status(self): self.task_status = TaskStatus(name="Open", short_name="opn", color="#FFFFFF") self.task_status.save() def generate_fixture_task_status_wip(self): self.task_status_wip = TaskStatus(name="WIP", short_name="wip", color="#FFFFFF") self.task_status_wip.save() def generate_fixture_task_status_to_review(self): self.task_status_to_review = TaskStatus(name="To review", short_name="pndng", color="#FFFFFF") self.task_status_to_review.save() def generate_fixture_assigner(self): self.assigner = Person(first_name="Ema", last_name="Peel") self.assigner.save() def generate_fixture_task(self): start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.task = Task(name="Super modeling", project_id=self.project.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=self.entity.id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date) self.task.save() def generate_fixture_task_standard(self): start_date = fields.get_date_object("2017-02-20") due_date = fields.get_date_object("2017-02-28") real_start_date = fields.get_date_object("2017-02-22") self.task_standard = Task(name="Super modeling", project_id=self.project_standard.id, task_type_id=self.task_type.id, task_status_id=self.task_status.id, entity_id=self.entity_standard.id, assignees=[self.person], assigner_id=self.assigner.id, duration=50, estimation=40, start_date=start_date, due_date=due_date, real_start_date=real_start_date) self.task_standard.save() def generate_fixture_shot_task(self): self.shot_task = Task( name="Super animation", project_id=self.project.id, task_type_id=self.task_type_animation.id, task_status_id=self.task_status.id, entity_id=self.shot.id, assignees=[self.person], assigner_id=self.assigner.id, ) self.shot_task.save() def generate_fixture_shot_task_standard(self): self.shot_task_standard = Task( name="Super animation", project_id=self.project_standard.id, task_type_id=self.task_type_animation.id, task_status_id=self.task_status.id, entity_id=self.shot_standard.id, assignees=[self.person], assigner_id=self.assigner.id) self.shot_task_standard.save() def generate_fixture_file_status(self): self.file_status = FileStatus(name="To review", color="#FFFFFF") self.file_status.save() def generate_fixture_working_file(self): self.working_file = WorkingFile(name="S01_P01_modeling", comment="", revision=1, task_id=self.task.id, entity_id=self.entity.id, person_id=self.person.id) self.working_file.save() def generate_fixture_shot_working_file(self): self.working_file = WorkingFile(name="S01_P01_animation", comment="", revision=1, task_id=self.task.id, entity_id=self.shot.id, person_id=self.person.id) self.working_file.save() def generate_fixture_output_file(self): self.output_file = OutputFile(comment="", revision=1, task_id=self.task.id, entity_id=self.entity.id, person_id=self.person.id, file_status_id=self.file_status.id) self.output_file.save() def get_fixture_file_path(self, relative_path): current_path = os.getcwd() file_path_fixture = os.path.join(current_path, "test", "fixtures", relative_path) return file_path_fixture
def import_row(self, row): project_name = row["Project"] department_name = row["Department"] task_type_name = row["Task Type"] task_status_name = row["Task Status"] entity_type_name = row["Asset Type"] entity_name = row["Asset"] episode_name = row["Episode"] sequence_name = row["Sequence"] shot_name = row["Shot"] name = row["Name"] assigner_name = row["Assigner"] assignee_name = row["Assignee"] duration = int(row["Duration"]) * 3600 estimation = int(row["Estimation"]) * 3600 start_date = self.normalize_date(row["Start Date"]) real_start_date = self.normalize_date(row["Real Start Date"]) due_date = self.normalize_date(row["Due Date"]) end_date = self.normalize_date(row["End Date"]) self.add_to_cache_if_absent(self.task_statuses, tasks_service.get_or_create_status, task_status_name) task_status_id = self.get_id_from_cache(self.task_statuses, task_status_name) self.add_to_cache_if_absent(self.departments, tasks_service.get_or_create_department, department_name) department_id = self.get_id_from_cache(self.departments, department_name) task_type_key = "%s-%s" % (department_id, task_type_name) if task_type_key not in self.task_types: department = self.departments[department_name] self.task_types[task_type_key] = \ tasks_service.get_or_create_task_type( department, task_type_name ) task_type_id = self.get_id_from_cache(self.task_types, task_type_key) project_id = self.projects[project_name].id assigner_id = self.persons[assigner_name].id assignee = self.persons.get(assignee_name, None) if len(shot_name) > 0: episode_id = self.episodes[str(project_id) + episode_name]["id"] sequence_id = self.sequences[str(project_id) + str(episode_id) + sequence_name]["id"] entity_id = self.shots[str(project_id) + str(sequence_id) + shot_name]["id"] else: entity_type_id = self.entity_types[entity_type_name].id entity_id = self.entities[str(project_id) + str(entity_type_id) + entity_name].id task = Task.create(name=name, project_id=project_id, task_type_id=task_type_id, entity_id=entity_id, task_status_id=task_status_id, assigner_id=assigner_id, duration=duration, estimation=estimation, start_date=start_date, end_date=end_date, real_start_date=real_start_date, due_date=due_date) if assignee is not None: task.assignees.append(assignee) task.save() return task
def reset_tasks_data(project_id): for task in Task.get_all_by(project_id=project_id): reset_task_data(str(task.id))