def get_episodes_for_project(project_id, only_assigned=False):
"""
Retrieve all episodes related to given project.
"""
if only_assigned:
Sequence = aliased(Entity, name="sequence")
Shot = aliased(Entity, name="shot")
Asset = aliased(Entity, name="asset")
query = (
Entity.query.join(Sequence, Entity.id == Sequence.parent_id)
.join(Shot, Sequence.id == Shot.parent_id)
.join(Task, Shot.id == Task.entity_id)
.filter(Entity.project_id == project_id)
.filter(user_service.build_assignee_filter())
)
shot_episodes = fields.serialize_models(query.all())
shot_episode_ids = {episode["id"]: True for episode in shot_episodes}
query = (
Entity.query.join(Asset, Entity.id == Asset.source_id)
.join(Task, Asset.id == Task.entity_id)
.filter(Entity.project_id == project_id)
.filter(user_service.build_assignee_filter())
)
asset_episodes = fields.serialize_models(query.all())
result = shot_episodes
for episode in asset_episodes:
if episode["id"] not in shot_episode_ids:
result.append(episode)
return result
else:
return entities_service.get_entities_for_project(
project_id, get_episode_type()["id"], "Episode"
)
def get_preview_files_for_entity(entity_id):
"""
Get all preview files available for given shot.
"""
tasks = tasks_service.get_task_dicts_for_entity(entity_id)
previews = {}
for task in tasks:
preview_files = (PreviewFile.query.filter_by(
task_id=task["id"]).join(Task).join(TaskType).order_by(
TaskType.priority.desc()).order_by(TaskType.name).order_by(
PreviewFile.revision.desc()).order_by(
PreviewFile.created_at).all())
task_type_id = task["task_type_id"]
if len(preview_files) > 0:
preview_files = fields.serialize_models(preview_files)
preview_files = mix_preview_file_revisions(preview_files)
previews[task_type_id] = [
{
"id": preview_file["id"],
"revision": preview_file["revision"],
"extension": preview_file["extension"],
"annotations": preview_file["annotations"],
"previews": preview_file["previews"],
"created_at": preview_file["created_at"],
"task_id": preview_file["task_id"]
} for preview_file in preview_files
] # Do not add too much field to avoid building too big responses
return previews
def get_last_output_files_for_instance(
asset_instance_id,
temporal_entity_id,
task_type_id=None,
output_type_id=None,
name=None,
representation=None,
file_status_id=None,
):
"""
Get last output files for given entity grouped by output type and name.
"""
# Query maximum revision for each possible arguments
query = OutputFile.query.with_entities(
OutputFile.temporal_entity_id,
OutputFile.task_type_id,
OutputFile.output_type_id,
OutputFile.name,
OutputFile.representation,
func.max(OutputFile.revision).label("MAX"),
).group_by(
OutputFile.temporal_entity_id,
OutputFile.task_type_id,
OutputFile.output_type_id,
OutputFile.name,
OutputFile.representation,
)
query = query.filter(OutputFile.asset_instance_id == asset_instance_id)
query = query.filter(OutputFile.temporal_entity_id == temporal_entity_id)
statement = query.subquery()
# Create a join query to retrieve maximum revision
query = OutputFile.query.join(
statement,
and_(
OutputFile.temporal_entity_id == statement.c.temporal_entity_id,
OutputFile.task_type_id == statement.c.task_type_id,
OutputFile.output_type_id == statement.c.output_type_id,
OutputFile.name == statement.c.name,
OutputFile.representation == statement.c.representation,
OutputFile.revision == statement.c.MAX,
),
)
# Filter by specified arguments
query = query.filter(OutputFile.asset_instance_id == asset_instance_id)
query = query.filter(OutputFile.temporal_entity_id == temporal_entity_id)
if task_type_id:
query = query.filter(OutputFile.task_type_id == task_type_id)
if output_type_id:
query = query.filter(OutputFile.output_type_id == output_type_id)
if name:
query = query.filter(OutputFile.name == name)
if representation:
query = query.filter(OutputFile.representation == representation)
if representation:
query = query.filter(OutputFile.file_status_id == file_status_id)
output_files = query.all()
return fields.serialize_models(output_files)
def get_last_working_files_for_task(task_id):
"""
Get last revisions for given task grouped by file name.
"""
query = WorkingFile.query.with_entities(
WorkingFile.name,
WorkingFile.task_id,
func.max(WorkingFile.revision).label("MAX"),
).group_by(
WorkingFile.name,
WorkingFile.task_id,
)
query = query.filter(WorkingFile.task_id == task_id)
statement = query.subquery()
query = WorkingFile.query.join(
statement,
and_(
WorkingFile.task_id == statement.c.task_id,
WorkingFile.name == statement.c.name,
WorkingFile.revision == statement.c.MAX,
),
)
# query
working_files = fields.serialize_models(query.all())
# group by name
working_files_by_name = {
k: list(v)[0]
for k, v in itertools.groupby(working_files, key=itemgetter('name'))
}
return working_files_by_name
def get_all_attachment_files_for_task(task_id):
"""
Return all attachment files listed into given task.
"""
attachment_files = (AttachmentFile.query.join(Comment).join(
Task, Task.id == Comment.object_id).filter(Task.id == task_id))
return fields.serialize_models(attachment_files)
def get_output_files_for_instance(
asset_instance_id,
temporal_entity_id,
task_type_id=None,
output_type_id=None,
name=None,
representation=None,
file_status_id=None,
):
"""
Return output files for given instance ordered by revision.
"""
query = OutputFile.query.filter_by(asset_instance_id=asset_instance_id)
if temporal_entity_id:
query = query.filter(
OutputFile.temporal_entity_id == temporal_entity_id)
if task_type_id:
query = query.filter(OutputFile.task_type_id == task_type_id)
if output_type_id:
query = query.filter(OutputFile.output_type_id == output_type_id)
if name:
query = query.filter(OutputFile.name == name)
if representation:
query = query.filter(OutputFile.representation == representation)
if file_status_id:
query = query.filter(OutputFile.file_status_id == file_status_id)
output_files = (query.filter(OutputFile.revision >= 0).order_by(
desc(OutputFile.revision)).all())
return fields.serialize_models(output_files)
def post(self):
results = []
self.sg_entries = request.json
self.check_permissions()
self.prepare_import()
for sg_entry in self.filtered_entries():
try:
data = self.extract_data(sg_entry)
result_entry = self.import_entry(data)
results.append(result_entry)
except ShotgunEntryImportFailed as exception:
current_app.logger.warn(exception)
except KeyError as exception:
current_app.logger.warn(exception)
current_app.logger.error(
"Your data is not properly formatted: %s" % sg_entry
)
except IntegrityError:
current_app.logger.error(
"Data information are duplicated or wrong: %s" %
sg_entry
)
self.post_processing()
return fields.serialize_models(results), 200
def get_task_types_for_entity(entity_id):
"""
Return all task types for which there is a task related to given entity.
"""
task_types = (TaskType.query.join(
Task, Entity).filter(Entity.id == entity_id).all())
return fields.serialize_models(task_types)
def get_task_types_for_project(project_id):
"""
Return all task types for which there is a task related to given project.
"""
task_types = (TaskType.query.join(Task).filter(
Task.project_id == project_id).distinct(TaskType.id).all())
return fields.serialize_models(task_types)
def get_processing_preview_files_for_project():
"""
"""
preview_files = (PreviewFile.query.join(Task).filter(
PreviewFile.status.in_(("Broken", "Processing"))).add_column(
Task.task_status_id).add_column(Task.entity_id))
return fields.serialize_models(preview_files)
def get_output_files_for_entity(entity_id):
"""
Return output files for given entity ordered by revision.
"""
output_files = OutputFile.query.filter_by(entity_id=entity_id).filter(
OutputFile.revision >= 0).order_by(desc(OutputFile.revision)).all()
return fields.serialize_models(output_files)
def get_preview_files_for_task(task_id):
"""
Get all preview files for given task.
"""
previews = PreviewFile.filter_by(task_id=task_id).order_by(
PreviewFile.revision.desc())
return fields.serialize_models(previews)
def get_active_persons():
"""
Return all person with flag active set to True.
"""
persons = (Person.query.filter_by(active=True).order_by(
Person.first_name).order_by(Person.last_name).all())
return fields.serialize_models(persons)
def get_last_output_files_for_entity(
entity_id,
task_type_id=None,
output_type_id=None,
name=None,
representation=None,
):
"""
Get last output files for given parameters.
We use a subquery to get maximum revision and then filter with given
params.
"""
# Query maximum revision for each possible arguments
query = OutputFile.query.with_entities(
OutputFile.task_type_id,
OutputFile.output_type_id,
OutputFile.name,
OutputFile.representation,
func.max(OutputFile.revision).label("MAX"),
).group_by(
OutputFile.task_type_id,
OutputFile.output_type_id,
OutputFile.name,
OutputFile.representation,
)
query = query.filter(OutputFile.entity_id == entity_id)
query = query.filter(OutputFile.asset_instance_id == None)
statement = query.subquery()
# Create a join query to retrieve maximum revision and filter by
# specified arguments
query = OutputFile.query.join(
statement,
and_(
OutputFile.task_type_id == statement.c.task_type_id,
OutputFile.output_type_id == statement.c.output_type_id,
OutputFile.name == statement.c.name,
OutputFile.representation == statement.c.representation,
OutputFile.revision == statement.c.MAX,
),
)
# Filter by specified arguments
if task_type_id:
query = query.filter(OutputFile.task_type_id == task_type_id)
if output_type_id:
query = query.filter(OutputFile.output_type_id == output_type_id)
if name:
query = query.filter(OutputFile.name == name)
if representation:
query = query.filter(OutputFile.representation == representation)
query = query.filter(OutputFile.entity_id == entity_id)
query = query.filter(OutputFile.asset_instance_id == None)
# query
output_files = query.all()
return fields.serialize_models(output_files)
def post(self):
kitsu_entries = request.json
instances = []
for entry in kitsu_entries:
if self.pre_check_entry():
instance = self.model.create_from_import(entry)
instances.append(instance)
return fields.serialize_models(instances)
def get_preview_files_for_revision(task_id, revision):
"""
Get all preview files for given task and revision.
"""
preview_files = (PreviewFile.query.filter_by(task_id=task_id,
revision=revision).order_by(
PreviewFile.position))
return fields.serialize_models(preview_files)
def get_working_files_for_task(task_id):
"""
Retrieve all working files for a given task ordered by revision from
biggest to smallest revision.
"""
working_files = WorkingFile.query.filter_by(task_id=task_id).filter(
WorkingFile.revision >= 0).order_by(desc(WorkingFile.revision)).all()
return fields.serialize_models(working_files)
def get_metadata_descriptors(project_id):
"""
Get all metadata descriptors for given project and entity type.
"""
descriptors = MetadataDescriptor.query \
.filter(MetadataDescriptor.project_id == project_id) \
.order_by(MetadataDescriptor.name) \
.all()
return fields.serialize_models(descriptors)
def get_all_attachment_files_for_project(project_id):
"""
Return all attachment files listed into given project. It is mainly needed
for synchronisation purposes.
"""
attachment_files = (AttachmentFile.query.join(Comment).join(
Task,
Task.id == Comment.object_id).filter(Task.project_id == project_id))
return fields.serialize_models(attachment_files)
def post(self):
kitsu_entries = request.json
if type(kitsu_entries) != list:
raise WrongParameterException("A list of entities is expected.")
instances = []
for entry in kitsu_entries:
if self.pre_check_entry():
instance = self.model.create_from_import(entry)
instances.append(instance)
return fields.serialize_models(instances)
def get_output_files_for_instance(asset_instance_id, temporal_entity_id):
"""
Return output files for given instance ordered by revision.
"""
output_files = OutputFile.query.filter_by(
asset_instance_id=asset_instance_id,
temporal_entity_id=temporal_entity_id).filter(
OutputFile.revision >= 0).order_by(desc(
OutputFile.revision)).all()
return fields.serialize_models(output_files)
def get_task_types_for_episode(episode_id):
"""
Return all task types for which there is a task related to given episode.
"""
Sequence = aliased(Entity, name="sequence")
Episode = aliased(Entity, name="episode")
task_types = (TaskType.query.join(Task, Entity).join(
Sequence, Sequence.id == Entity.parent_id).join(
Episode, Episode.id == Sequence.parent_id).filter(
Episode.id == episode_id).group_by(TaskType.id).all())
return fields.serialize_models(task_types)
def get_metadata_descriptors(project_id, for_client=False):
"""
Get all metadata descriptors for given project and entity type.
"""
query = MetadataDescriptor.query.filter(
MetadataDescriptor.project_id == project_id).order_by(
MetadataDescriptor.name)
if for_client:
query = query.filter(MetadataDescriptor.for_client == True)
descriptors = query.all()
return fields.serialize_models(descriptors)
def get_sequences_for_episode(episode_id, only_assigned=False):
"""
Retrieve all sequences related to given episode.
"""
if only_assigned:
Shot = aliased(Entity, name="shot")
query = (Entity.query.join(Shot, Entity.id == Shot.parent_id).join(
Task, Shot.id == Task.entity_id).filter(
Entity.parent_id == episode_id).filter(
user_service.build_assignee_filter()))
return fields.serialize_models(query.all())
else:
return get_episodes({"parent_id": episode_id})
def get_sequences_for_project(project_id, only_assigned=False):
"""
Retrieve all sequences related to given project.
"""
if only_assigned:
Shot = aliased(Entity, name="shot")
query = (Entity.query.join(Shot, Entity.id == Shot.parent_id).join(
Task, Shot.id == Task.entity_id).filter(
Entity.project_id == project_id).filter(
user_service.build_assignee_filter()))
return fields.serialize_models(query.all())
else:
return entities_service.get_entities_for_project(
project_id,
get_sequence_type()["id"], "Sequence")
def get_working_files_for_entity(entity_id, task_id=None, name=None):
"""
Retrieve all working files for a given entity and specified parameters
ordered by revision from biggest to smallest revision.
"""
query = WorkingFile.query.filter_by(entity_id=entity_id)
if task_id:
query = query.filter(WorkingFile.task_id == task_id)
if name:
query = query.filter(WorkingFile.name == name)
query = query.filter(WorkingFile.revision >= 0).order_by(
desc(WorkingFile.revision))
working_files = query.all()
return fields.serialize_models(working_files)
def get_person_related_tasks(person_id, task_type_id):
"""
Retrieve all tasks for given task types and to entiities
that have at least one person assignation.
"""
person = Person.get(person_id)
projects = projects_service.open_projects()
project_ids = [project["id"] for project in projects]
entities = (Entity.query.join(Task, Entity.id == Task.entity_id).filter(
Task.assignees.contains(person)).filter(
Entity.project_id.in_(project_ids))).all()
entity_ids = [entity.id for entity in entities]
tasks = (Task.query.filter(Task.entity_id.in_(entity_ids)).filter(
Task.task_type_id == task_type_id)).all()
return fields.serialize_models(tasks)
def post(self):
uploaded_file = request.files["file"]
file_name = "%s.csv" % uuid.uuid4()
file_path = os.path.join(app.config["TMP_DIR"], file_name)
uploaded_file.save(file_path)
result = []
self.prepare_import()
try:
with open(file_path) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
result.append(self.import_row(row))
return fields.serialize_models(result), 201
except KeyError as e:
return {"error": "A column is missing: %s" % e}, 400
def post(self):
kitsu_entries = request.json
if type(kitsu_entries) != list:
raise WrongParameterException("A list of entities is expected.")
instances = []
for entry in kitsu_entries:
if self.check_access(entry):
try:
(instance,
is_updated) = self.model.create_from_import(entry)
if is_updated:
self.emit_event("update", entry)
else:
self.emit_event("new", entry)
except IntegrityError as exc:
raise WrongParameterException(exc.orig)
instances.append(instance)
return fields.serialize_models(instances)
def get_output_files_for_instance(
asset_instance_id,
temporal_entity_id,
task_type_id=None,
output_type_id=None,
name=None,
representation=None,
file_status_id=None,
created_at_since=None,
person_id=None,
):
"""
Return output files for given instance ordered by revision.
"""
query = OutputFile.query.filter_by(asset_instance_id=asset_instance_id)
if temporal_entity_id:
query = query.filter(
OutputFile.temporal_entity_id == temporal_entity_id)
if task_type_id:
query = query.filter(OutputFile.task_type_id == task_type_id)
if output_type_id:
query = query.filter(OutputFile.output_type_id == output_type_id)
if name:
query = query.filter(OutputFile.name == name)
if representation:
query = query.filter(OutputFile.representation == representation)
if file_status_id:
query = query.filter(OutputFile.file_status_id == file_status_id)
if created_at_since:
days = datetime.datetime.now() - datetime.timedelta(
days=int(created_at_since))
query = query.filter(OutputFile.created_at >= days)
if person_id:
query = query.filter(OutputFile.person_id == person_id)
output_files = (query.filter(OutputFile.revision >= 0).order_by(
desc(OutputFile.revision)).all())
return fields.serialize_models(output_files, relations=True)
