def setUp(self): super(QueryTestCase, self).setUp() self.generate_fixture_project_status() self.generate_fixture_project() self.project_id = self.project.id project = Project(name='Kitchen', project_status_id=self.open_status.id) project.save() self.project2_id = project.id self.entity_type = EntityType(name='Shot Cosmos Landromat') self.entity_type.save() self.generate_data(Entity, 3, entities_out=[], entities_in=[], project_id=self.project_id, entity_type_id=self.entity_type.id) self.generate_data(Entity, 2, entities_out=[], entities_in=[], project_id=self.project2_id, entity_type_id=self.entity_type.id)
class FolderPathTestCase(ApiDBTestCase): def setUp(self): super(FolderPathTestCase, self).setUp() self.generate_fixture_project_status() self.project_standard = Project( name='Iris', project_status_id=self.open_status.id ) self.project_standard.save() def test_set_file_tree(self): tree = file_tree.get_tree_from_file('standard') path = "project/%s/set-tree" % self.project_standard.id project = self.post(path, {"tree_name": "standard"}, 200) self.assertEquals(project["file_tree"], tree) project = self.get("data/projects/%s" % self.project_standard.id) self.assertEquals(project["file_tree"], tree) def test_set_file_tree_400(self): path = "project/%s/set-tree" % self.project_standard.id self.post(path, {"name": "standard"}, 400) self.post(path, {"tree_name": "not_exist"}, 400) def test_set_file_tree_404(self): path = "project/not-exist/set-tree" self.post(path, {"tree_name": "standard"}, 404)
def test_project(self): project_id = "d98a6269-e566-4e11-b29f-b3faa2039d79" project_name = "Caminandes" Project.create_from_import({ "team": [str(self.person.id)], "id": project_id, "created_at": "2019-06-20T12:28:16", "updated_at": "2019-08-30T12:48:09", "name": project_name, "has_avatar": True, "fps": "25", "production_type": "tvshow", "start_date": "2019-07-01", "end_date": "2021-12-31", "project_status_id": str(self.open_status.id), "type": "Project" }) project = Project.get(project_id) self.assertEqual(project.name, project_name)
def test_get_or_create_instance_by_name(self): self.assertIsNone(Project.get_by(name="Test")) project = \ base_service.get_or_create_instance_by_name(Project, name="Test") self.assertIsNotNone(Project.get_by(name="Test")) project_again = \ base_service.get_or_create_instance_by_name(Project, name="Test") self.assertEquals(project["id"], project_again["id"])
def setUp(self): super(FolderPathTestCase, self).setUp() self.generate_fixture_project_status() self.project_standard = Project( name='Iris', project_status_id=self.open_status.id ) self.project_standard.save()
def get_or_create(name): project = Project.get_by(name=name) if project is None: open_status = get_or_create_open_status() project = Project( name=name, project_status_id=open_status.id ) project.save() return project
def test_sync_event(self): sync_service.sync_event({ "name": "project:new", "data": { "project_id": self.new_project_id } }) self.assertIsNotNone(Project.get(self.new_project_id)) sync_service.sync_event({ "name": "project:delete", "data": { "project_id": self.new_project_id } }) self.assertIsNone(Project.get(self.new_project_id))
def get_full_asset(asset_id): asset = get_asset(asset_id) asset_type = get_asset_type_raw(asset["entity_type_id"]) project = Project.get(asset["project_id"]) asset["project_name"] = project.name asset["asset_type_id"] = str(asset_type.id) asset["asset_type_name"] = asset_type.name tasks = Task.query \ .filter_by(entity_id=asset_id) \ .all() task_dicts = [] for task in tasks: task_dicts.append({ "id": str(task.id), "task_status_id": str(task.task_status_id), "task_type_id": str(task.task_type_id), "assignees": [str(assignee.id) for assignee in task.assignees] }) asset["tasks"] = task_dicts return asset
def task_to_review(task_id, person, comment, preview_path=""): task = get_task_raw(task_id) 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) task_dict_after = task.serialize() 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 task_dict_after["comment"] = comment task_dict_after["preview_path"] = preview_path events.emit("task:to-review", { "task_before": task_dict_before, "task_after": task_dict_after }) return task_dict_after
def test_import_sequence(self): self.load_fixture('projects') sg_sequence = { "project": { "type": "Project", "id": 1, "name": "Cosmos Landromat" }, "code": "S04", "type": "Sequence", "id": 4, "description": "test description" } api_path = "data/import/shotgun/sequences" self.sequences = self.post(api_path, [sg_sequence], 200) self.assertEqual(len(self.sequences), 1) self.sequences = self.get("data/sequences") self.assertEqual(len(self.sequences), 1) sequence = self.sequences[0] project = Project.get_by(name="Cosmos Landromat") self.assertEqual(sequence["name"], sg_sequence["code"]) self.assertEqual(sequence["description"], sg_sequence["description"]) self.assertEqual(sequence["shotgun_id"], sg_sequence["id"]) self.assertEqual(sequence["project_id"], str(project.id))
def task_to_review(task_id, person, comment, preview_path=""): """ Change the task status to "waiting for approval" if it is not already the case. It emits a *task:to-review* event. Change the real start date time to now. """ task = get_task_raw(task_id) 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) task_dict_after = task.serialize() 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 task_dict_after["comment"] = comment task_dict_after["preview_path"] = preview_path events.emit("task:to-review", { "task_before": task_dict_before, "task_after": task_dict_after }) return task_dict_after
def get_project_by_name(project_name): project = Project.get_by(name=project_name) if project is None: raise ProjectNotFoundException() return project
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_import_asset(self): self.load_fixture('projects') sg_asset = { "code": "Cake", "description": "yellow cake", "project": { "type": "Project", "id": 1, "name": "Cosmos Landromat" }, "sg_asset_type": "Props", "type": "Asset", "id": 3 } api_path = "data/import/shotgun/assets" self.assets = self.post(api_path, [sg_asset], 200) self.assertEqual(len(self.assets), 1) self.assets = self.get("data/entities") self.assertEqual(len(self.assets), 1) asset = self.assets[0] project = Project.get_by(shotgun_id=sg_asset["project"]["id"]) self.assertEqual(asset["description"], sg_asset["description"]) self.assertEqual(asset["shotgun_id"], sg_asset["id"]) self.assertEqual(asset["project_id"], str(project.id))
def save(self): self.generate_fixture_project_status() project = self.generate_fixture_project() project.name = "new name" project.save() project = Project.get(project.id) self.assertEqual(project.name, "new name")
def test_import_shot(self): self.load_fixture('projects') self.load_fixture('sequences') self.load_fixture('assets') self.load_fixture('scenes') api_path = "/import/shotgun/shots" self.shots = self.post(api_path, [self.sg_shot], 200) self.assertEqual(len(self.shots), 1) self.shots = self.get("data/shots/all") self.assertEqual(len(self.shots), 1) shot = self.shots[0] sequence = Entity.get_by( shotgun_id=self.sg_shot["sg_sequence"]["id"], entity_type_id=shots_service.get_sequence_type()["id"] ) entity = Entity.get_by(name=self.sg_shot["assets"][0]["name"]) project = Project.get_by(name=self.sg_shot["project"]["name"]) scene = Entity.get_by(name=self.sg_shot["sg_scene"]["name"]) self.assertEqual(shot["name"], self.sg_shot["code"]) self.assertEqual(shot["data"]["frame_in"], 0) self.assertEqual(shot["data"]["frame_out"], 122) self.assertEqual(shot["data"]["sg_custom_field"], "test") self.assertEqual(shot["parent_id"], str(sequence.id)) self.assertEqual(shot["entities_out"][0], str(entity.id)) self.assertEqual(shot["project_id"], str(project.id)) self.assertEqual(shot["source_id"], str(scene.id))
def related_projects(): projects = Project.query \ .join(Task) \ .filter(assignee_filter()) \ .filter(open_project_filter()) \ .all() return Project.serialize_list(projects)
def generate_fixture_project(self, name="Cosmos Landromat"): self.project = Project.create(name=name, project_status_id=self.open_status.id) self.project_id = self.project.id self.project.update( {"file_tree": file_tree_service.get_tree_from_file("simple")}) return self.project
def test_import_task(self): self.load_task() self.assertEqual(len(self.tasks), 1) self.tasks = self.get("data/tasks") self.assertEqual(len(self.tasks), 1) task = self.tasks[0] task = tasks_service.get_task_with_relations(task["id"]) project = Project.get_by(name=self.sg_task["project"]["name"]) task_type = \ TaskType.get_by(name=self.sg_task["step"]["name"]) task_status = TaskStatus.get_by( short_name=self.sg_task["sg_status_list"]) assets = assets_service.get_assets( {"shotgun_id": self.sg_task["entity"]["id"]}) entity = assets[0] assigner = Person.get_by( last_name=self.sg_task["created_by"]["name"].split(" ")[1]) assignee = Person.get_by( last_name=self.sg_task["task_assignees"][0]["name"].split(" ")[1]) self.assertEqual(task["name"], self.sg_task["cached_display_name"]) self.assertEqual(task["duration"], self.sg_task["duration"]) self.assertEqual(task["shotgun_id"], self.sg_task["id"]) self.assertEqual(task["project_id"], str(project.id)) self.assertEqual(task["task_type_id"], str(task_type.id)) self.assertEqual(task["task_status_id"], str(task_status.id)) self.assertEqual(task["entity_id"], entity["id"]) self.assertEqual(task["assigner_id"], str(assigner.id)) self.assertEqual(task["assignees"][0], str(assignee.id))
def get_full_shot(shot_id): shot = get_shot(shot_id) sequence = Entity.get(shot["parent_id"]) project = Project.get(shot["project_id"]) shot["project_name"] = project.name shot["sequence_id"] = str(sequence.id) shot["sequence_name"] = sequence.name if sequence.parent_id is not None: episode = Entity.get(sequence.parent_id) shot["episode_id"] = str(episode.id) shot["episode_name"] = episode.name tasks = Task.query \ .filter_by(entity_id=shot_id) \ .all() task_dicts = [] for task in tasks: task_dicts.append({ "id": str(task.id), "task_status_id": str(task.task_status_id), "task_type_id": str(task.task_type_id), "assignees": [str(assignee.id) for assignee in task.assignees] }) shot["tasks"] = task_dicts return shot
def prepare_import(self): self.project_ids = Project.get_id_map() self.person_ids = Person.get_id_map() self.task_type_ids = TaskType.get_id_map(field="name") self.task_status_ids = TaskStatus.get_id_map(field="short_name") self.asset_ids = self.get_asset_map() self.shot_ids = self.get_shot_map()
def generate_fixture_project_no_preview_tree(self): self.project_no_preview_tree = Project.create( name="Agent 327", project_status_id=self.open_status.id ) self.project_no_preview_tree.update( {"file_tree": file_tree_service.get_tree_from_file("no_preview")} )
def test_import_sequence(self): self.load_fixture("projects") self.load_fixture("episodes") sg_sequence = { "project": {"type": "Project", "id": 1, "name": "Agent327"}, "episode": {"type": "Episode", "id": 1, "name": "E01"}, "code": "S04", "type": "Sequence", "id": 4, "description": "test description", } api_path = "/import/shotgun/sequences" self.sequences = self.post(api_path, [sg_sequence], 200) self.assertEqual(len(self.sequences), 1) self.sequences = self.get("data/sequences") self.assertEqual(len(self.sequences), 1) sequence = self.sequences[0] project = Project.get_by(name="Agent327") episode = Entity.get_by(name="E01") self.assertEqual(sequence["name"], sg_sequence["code"]) self.assertEqual(sequence["description"], sg_sequence["description"]) self.assertEqual(sequence["shotgun_id"], sg_sequence["id"]) self.assertEqual(sequence["project_id"], str(project.id)) self.assertEqual(sequence["parent_id"], str(episode.id))
def generate_fixture_project_standard(self): self.project_standard = Project.create( name="Big Buck Bunny", project_status_id=self.open_status.id ) self.project_standard.update( {"file_tree": file_tree_service.get_tree_from_file("default")} )
def test_import_episode(self): self.load_fixture('projects') sg_episode = { "project": { "type": "Project", "id": 4, "name": "Agent327" }, "code": "E04", "type": "Episode", "id": 4, "description": "test description" } api_path = "/import/shotgun/episodes" self.episodes = self.post(api_path, [sg_episode], 200) self.assertEqual(len(self.episodes), 1) self.episodes = self.get("data/episodes") self.assertEqual(len(self.episodes), 1) episode = self.episodes[0] project = Project.get_by(name="Agent327") self.assertEqual(episode["name"], sg_episode["code"]) self.assertEqual(episode["description"], sg_episode["description"]) self.assertEqual(episode["shotgun_id"], sg_episode["id"]) self.assertEqual(episode["project_id"], str(project.id))
def get_full_asset(asset_id): """ Return asset matching given id with additional information (project name, asset type name and tasks). """ asset = get_asset(asset_id) asset_type = get_asset_type(asset["entity_type_id"]) project = Project.get(asset["project_id"]) asset["project_name"] = project.name asset["asset_type_id"] = asset_type["id"] asset["asset_type_name"] = asset_type["name"] tasks = Task.query \ .filter_by(entity_id=asset_id) \ .all() task_dicts = [] for task in tasks: task_dicts.append({ "id": str(task.id), "task_status_id": str(task.task_status_id), "task_type_id": str(task.task_type_id), "assignees": [str(assignee.id) for assignee in task.assignees] }) asset["tasks"] = task_dicts return asset
def get_project_from_preview_file(preview_file_id): """ Get project dict of related preview file. """ preview_file = files_service.get_preview_file_raw(preview_file_id) task = Task.get(preview_file.task_id) project = Project.get(task.project_id) return project.serialize()
def test_get_id_map(self): self.generate_fixture_project_status() self.generate_fixture_project() project_id = self.generate_fixture_project("Second project").id project_map = Project.get_id_map(field="name") self.assertTrue("Second project" in project_map) project_id_again = project_map["Second project"] self.assertEqual(project_id_again, project_id)
def test_get_open_projects(self): projects = self.get("data/user/projects/open") self.assertEquals(len(projects), 0) project = Project.get(self.project_id) project.team.append(self.user) project.save() projects = self.get("data/user/projects/open") self.assertEquals(len(projects), 1) project = Project.get(self.project_id) project.team[:] = [] project.save() projects = self.get("data/user/projects/open") self.assertEquals(len(projects), 0)
def update(self): self.generate_fixture_project_status() project = self.generate_fixture_project() project.update({ "name": "new name" }) project = Project.get(project.id) self.assertEqual(project.name, "new name")