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