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)
def generate_fixture_asset_type(self): self.asset_type = EntityType.create(name="Props") self.asset_type_props = self.asset_type self.shot_type = EntityType.create(name="Shot") self.sequence_type = EntityType.create(name="Sequence") self.episode_type = EntityType.create(name="Episode") self.scene_type = EntityType.create(name="Scene")
def get_entity_type_by_name(name): """ Return entity type maching *name*. If it doesn't exist, it creates it. """ entity_type = EntityType.get_by(name=name) if entity_type is None: entity_type = EntityType.create(name=name) return entity_type.serialize()
def get_or_create_asset_type(name): """ For a given name, get matching asset type. Create if it does not exist. """ asset_type = EntityType.get_by(name=name) if asset_type is None: asset_type = EntityType.create(name=name) return asset_type.serialize(obj_type="AssetType")
def test_get_project_and_type_assets(self): entity_type = EntityType(name="VFX") entity_type.save() entity = Entity(name="Smoke", entity_type_id=entity_type.id, project_id=self.project.id) entity.save() path_ids = (self.project.id, self.entity_type.id) path = "data/projects/%s/asset_types/%s/assets" % path_ids assets = self.get(path) self.assertEquals(len(assets), 1) self.assertDictEqual(assets[0], self.entity_dict)
def get_or_create_asset_type(name): """ For a given name, get matching asset type. Create if it does not exist. """ asset_type = EntityType.get_by(name=name) if asset_type is None: asset_type = EntityType.create(name=name) clear_asset_type_cache() events.emit( "asset-type:new", {"name": asset_type.name, "id": asset_type.id} ) return asset_type.serialize(obj_type="AssetType")
def get_asset_type_by_name(asset_type_name): asset_type = EntityType.get_by(name=asset_type_name) if asset_type is None or not is_asset_type(asset_type): raise AssetTypeNotFoundException return asset_type.serialize(obj_type="AssetType")
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 update_entity_preview(entity_id, preview_file_id): """ Update given entity main preview. If entity or preview is not found, it raises an exception. """ entity = Entity.get(entity_id) if entity is None: raise EntityNotFoundException preview_file = PreviewFile.get(preview_file_id) if preview_file is None: raise PreviewFileNotFoundException entity.update({"preview_file_id": preview_file.id}) events.emit( "preview-file:set-main", { "entity_id": entity_id, "preview_file_id": preview_file_id }, ) entity_type = EntityType.get(entity.entity_type_id) entity_type_name = "asset" if entity_type.name in ["Shot", "Scene", "Sequence", "Episode"]: entity_type_name = entity_type.name.lower() events.emit( "%s:update" % entity_type_name, {"%s_id" % entity_type_name: str(entity.id)}, ) return entity.serialize()
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 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 get_folder_from_asset_type(asset): if asset is not None: asset_type = EntityType.get(asset.entity_type_id) folder = asset_type.name else: raise MalformedFileTreeException("Given asset is null.") return folder
def sanitize_import_data(self, data): from zou.app.models.preview_file import PreviewFile from zou.app.models.entity_type import EntityType entity_ids = [] model_type = data.get("type", "Shot") if "entities_out" in data: entity_ids = data["entities_out"] del data["entities_out"] if "asset_type_id" in data: data["entity_type_id"] = data["asset_type_id"] del data["asset_type_id"] del data["asset_type_name"] if "sequence_id" in data: data["parent_id"] = data["sequence_id"] del data["sequence_id"] if ( "preview_file_id" in data and data["preview_file_id"] is not None and len(data["preview_file_id"]) > 0 ): preview_file = PreviewFile.get(data["preview_file_id"]) if preview_file is None: del data["preview_file_id"] elif "preview_file_id" in data: del data["preview_file_id"] if "frame_in" in data: data["data"]["frame_in"] = data["frame_in"] del data["frame_in"] if "frame_out" in data: data["data"]["frame_out"] = data["frame_out"] del data["frame_out"] if "fps" in data: data["data"]["fps"] = data["fps"] del data["fps"] for field in [ "entities_in", "episode_id", "episode_name", "project_name", "sequence_name", "tasks", "type", ]: if field in data: del data[field] if model_type in ["Shot", "Sequence", "Episode"]: entity_type = EntityType.get_by(name=model_type) data["entity_type_id"] = entity_type.id return (data, entity_ids)
def test_create_asset_type_with_task_types(self): self.generate_fixture_department() self.department_id = self.department.id self.generate_fixture_task_type() task_types = [str(task_type.id) for task_type in TaskType.query.all()] task_types = [ str(self.task_type_concept.id), str(self.task_type_modeling.id), ] data = {"name": "FX", "task_types": task_types} self.asset_type = self.post("data/entity-types", data) self.assertIsNotNone(self.asset_type["id"]) self.assertEquals( set(self.asset_type["task_types"]), set(task_types), ) asset_types = self.get("data/entity-types") self.assertEqual(len(asset_types), 4) created_asset_type = EntityType.get(self.asset_type["id"]) self.assertEquals( set( str(task_type.id) for task_type in created_asset_type.task_types), set(task_types), )
def get_asset_types(criterions={}): """ Retrieve all asset types available. """ query = EntityType.query.filter(build_entity_type_asset_type_filter()) query = query_utils.apply_criterions_to_db_query(Entity, query, criterions) return EntityType.serialize_list(query.all(), obj_type="AssetType")
def get(self): """ Retrieve all entity types that are not shot or sequence. """ criterions = query.get_query_criterions_from_request(request) asset_types = asset_info.get_asset_types(criterions) return EntityType.serialize_list(asset_types)
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 get_assets(criterions={}): """ Get all assets for given criterions. """ query = Entity.query.filter(build_asset_type_filter()) query = query_utils.apply_criterions_to_db_query(Entity, query, criterions) result = query.all() return EntityType.serialize_list(result, obj_type="Asset")
def get_asset_type_raw(asset_type_id): try: asset_type = EntityType.get(asset_type_id) except StatementError: raise AssetTypeNotFoundException if asset_type is None or not is_asset_type(asset_type): raise AssetTypeNotFoundException return asset_type
def get_asset_types_for_shot(shot_id): shot = Entity.get(shot_id) asset_type_ids = [x.entity_type_id for x in shot.entities_out] if len(asset_type_ids) > 0: query = EntityType.query query = query.filter(EntityType.id.in_(asset_type_ids)) result = query.all() else: result = [] return EntityType.serialize_list(result, obj_type="AssetType")
def get_assets(criterions={}): shot_type = shots_service.get_shot_type() scene_type = shots_service.get_scene_type() sequence_type = shots_service.get_sequence_type() episode_type = shots_service.get_episode_type() query = Entity.query.filter_by(**criterions) result = query.filter(~Entity.entity_type_id.in_([ shot_type["id"], scene_type["id"], sequence_type["id"], episode_type["id"] ])).all() return EntityType.serialize_list(result, obj_type="Asset")
def get_project_asset_types(project_id): query = EntityType.query \ .join(Entity, Entity.entity_type_id == EntityType.id) \ .join(Task, Task.entity_id == Entity.id) \ .join(Project, ProjectStatus) \ .filter(Project.id == project_id) \ .filter(assignee_filter()) \ .filter(open_project_filter()) \ .filter(asset_type_filter()) return EntityType.serialize_list(query.all(), obj_type="AssetType")
def get_asset_types_for_project(project_id): asset_type_ids = [ x["entity_type_id"] for x in get_assets({"project_id": project_id}) ] if len(asset_type_ids) > 0: query = EntityType.query query = query.filter(EntityType.id.in_(asset_type_ids)) result = query.all() else: result = [] return EntityType.serialize_list(result, obj_type="AssetType")
class QueryTestCase(ApiDBTestCase): 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) def test_get_by_name(self): entities = self.get("data/entities") self.assertEquals(len(entities), 5) entities = self.get("data/entities?name=%s" % entities[0]['name']) self.assertEquals(len(entities), 1) entities = self.get("data/entities?name=%s&project_id=%s" % (entities[0]['name'], self.project_id)) self.assertEquals(len(entities), 1) entities = self.get("data/entities?name=%s&project_id=%s" % (entities[0]['name'], self.project2_id)) self.assertEquals(len(entities), 0)
def get_asset_type_raw(asset_type_id): """ Return given asset type instance as active record. """ try: asset_type = EntityType.get(asset_type_id) except StatementError: raise AssetTypeNotFoundException if asset_type is None or not is_asset_type(asset_type): raise AssetTypeNotFoundException return asset_type
def get_asset_types_for_shot(shot_id): """ Retrieve all asset types related to asset casted in a given shot. """ shot = Entity.get(shot_id) asset_type_ids = [x.entity_type_id for x in shot.entities_out] if len(asset_type_ids) > 0: query = EntityType.query query = query.filter(EntityType.id.in_(asset_type_ids)) result = query.all() else: result = [] return EntityType.serialize_list(result, obj_type="AssetType")
def get_assets(criterions={}): """ Get all assets for given criterions. """ query = Entity.query.filter(build_asset_type_filter()) assigned_to = False if "assigned_to" in criterions: assigned_to = True del criterions["assigned_to"] query = query_utils.apply_criterions_to_db_query(Entity, query, criterions) if assigned_to: query = query.outerjoin(Task) query = query.filter(user_service.build_assignee_filter()) result = query.all() return EntityType.serialize_list(result, obj_type="Asset")
def get_asset_types(criterions={}): shot_type = shots_service.get_shot_type() sequence_type = shots_service.get_sequence_type() episode_type = shots_service.get_episode_type() scene_type = shots_service.get_scene_type() asset_type_filter = ~EntityType.id.in_([ shot_type["id"], sequence_type["id"], episode_type["id"], scene_type["id"], ]) query = EntityType.query \ .filter_by(**criterions) \ .filter(asset_type_filter) return EntityType.serialize_list(query.all(), obj_type="AssetType")
def get_asset_types_for_project(project_id): """ Get all asset types for which there is an asset for which current user has a task assigned. Assets are listed in given project. """ query = EntityType.query \ .join(Entity, Entity.entity_type_id == EntityType.id) \ .join(Task, Task.entity_id == Entity.id) \ .join(Project, ProjectStatus) \ .filter(Project.id == project_id) \ .filter(build_assignee_filter()) \ .filter(build_open_project_filter()) \ .filter(assets_service.build_asset_type_filter()) return EntityType.serialize_list(query.all(), obj_type="AssetType")
def get_asset_types_for_project(project_id): """ Retrieve all asset types related to asset of a given project. """ asset_type_ids = [ x["entity_type_id"] for x in get_assets({"project_id": project_id}) ] if len(asset_type_ids) > 0: result = EntityType.query \ .filter(EntityType.id.in_(asset_type_ids)) \ .all() else: result = [] return EntityType.serialize_list(result, obj_type="AssetType")