def test_import_shots(self):
path = "/import/csv/projects/%s/shots" % self.project.id
self.project.update({"production_type": "tvshow"})
file_path_fixture = self.get_fixture_file_path(
os.path.join("csv", "shots.csv"))
self.upload_file(path, file_path_fixture)
sequences = shots_service.get_sequences()
self.assertEqual(len(sequences), 3)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 4)
entity_types = EntityType.query.all()
self.assertEqual(len(entity_types), 3)
shot = shots[0]
self.assertEqual(shot["data"].get("contractor", None), "contractor 1")
file_path_fixture = self.get_fixture_file_path(
os.path.join("csv", "shots_no_metadata.csv"))
self.upload_file("%s?update=true" % path, file_path_fixture)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 4)
entity_types = EntityType.query.all()
self.assertEqual(len(entity_types), 3)
shot = shots[0]
self.assertEqual(shot["data"].get("contractor", None), "contractor 1")
def test_remove_shot(self):
self.generate_fixture_asset()
path = "data/shots/%s" % self.shot.id
shots = shots_service.get_shots()
self.assertEqual(len(shots), 3)
self.delete(path)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 2)
def test_import_shots(self):
self.assertEqual(len(Task.query.all()), 0)
db.session.add(
ProjectTaskTypeLink(project_id=self.project_id,
task_type_id=self.task_type.id))
db.session.add(
ProjectTaskTypeLink(
project_id=self.project_id,
task_type_id=self.task_type_layout.id,
))
path = "/import/csv/projects/%s/shots" % self.project.id
self.project.update({"production_type": "tvshow"})
file_path_fixture = self.get_fixture_file_path(
os.path.join("csv", "shots.csv"))
self.upload_file(path, file_path_fixture)
sequences = shots_service.get_sequences()
self.assertEqual(len(sequences), 3)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 4)
entity_types = EntityType.query.all()
self.assertEqual(len(entity_types), 3)
tasks = Task.query.all()
self.assertEqual(
len(tasks),
len(shots),
)
shot = shots[0]
self.assertEqual(shot["data"].get("contractor", None), "contractor 1")
self.assertEqual(
set(str(task.entity_id) for task in tasks),
set(shot["id"] for shot in shots),
)
file_path_fixture = self.get_fixture_file_path(
os.path.join("csv", "shots_no_metadata.csv"))
self.upload_file("%s?update=true" % path, file_path_fixture)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 4)
entity_types = EntityType.query.all()
self.assertEqual(len(entity_types), 3)
shot = shots[0]
self.assertEqual(shot["data"].get("contractor", None), "contractor 1")
def prepare_import(self, project_id):
self.asset_type_map = {}
self.asset_map = {}
self.episode_map = {}
self.sequence_map = {}
self.shot_map = {}
asset_types = assets_service.get_asset_types()
for asset_type in asset_types:
self.asset_type_map[asset_type["id"]] = slugify(asset_type["name"])
assets = assets_service.get_assets({"project_id": project_id})
for asset in assets:
key = self.get_asset_key(asset)
self.asset_map[key] = asset["id"]
episodes = shots_service.get_episodes({"project_id": project_id})
for episode in episodes:
self.episode_map[episode["id"]] = slugify(episode["name"])
sequences = shots_service.get_sequences({"project_id": project_id})
for sequence in sequences:
key = self.get_sequence_key(sequence)
self.sequence_map[sequence["id"]] = key
shots = shots_service.get_shots({"project_id": project_id})
for shot in shots:
key = self.get_shot_key(shot)
self.shot_map[key] = shot["id"]
def post(self, task_type_id):
permissions.check_manager_permissions()
criterions = query.get_query_criterions_from_request(request)
shots = shots_service.get_shots(criterions)
task_type = tasks_service.get_task_type(task_type_id)
tasks = [tasks_service.create_task(task_type, shot) for shot in shots]
return tasks, 201
def get(self):
"""
Retrieve all shot entries. Filters can be specified in the query string.
"""
criterions = query.get_query_criterions_from_request(request)
if not permissions.has_manager_permissions():
user_service.check_criterions_has_task_related(criterions)
return shots_service.get_shots(criterions)
def post(self, task_type_id):
criterions = query.get_query_criterions_from_request(request)
if "project_id" not in criterions:
return {"error": True, "message": "Project ID is missing"}, 400
user_service.check_manager_project_access(criterions["project_id"])
shots = shots_service.get_shots(criterions)
task_type = tasks_service.get_task_type(task_type_id)
tasks = [tasks_service.create_task(task_type, shot) for shot in shots]
return tasks, 201
def get(self):
"""
Retrieve all shot entries. Filters can be specified in the query string.
"""
criterions = query.get_query_criterions_from_request(request)
if "sequence_id" in criterions:
sequence = shots_service.get_sequence(criterions["sequence_id"])
criterions["project_id"] = sequence["project_id"]
user_service.check_project_access(criterions)
return shots_service.get_shots(criterions)
def get(self, sequence_id):
"""
Retrieve all shot entries for a given sequence.
Filters can be specified in the query string.
"""
sequence = shots_service.get_sequence(sequence_id)
user_service.check_project_access(sequence["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = sequence_id
return shots_service.get_shots(criterions)
def get(self, sequence_id):
"""
Retrieve all shot entries for a given sequence.
Filters can be specified in the query string.
"""
sequence = shots_service.get_sequence(sequence_id)
if not permissions.has_manager_permissions():
user_service.check_has_task_related(sequence["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = sequence_id
return shots_service.get_shots(criterions)
def get(self, sequence_id):
"""
Retrieve all shot entries for a given sequence.
Filters can be specified in the query string.
"""
sequence = shots_service.get_sequence(sequence_id)
user_service.check_project_access(sequence["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = sequence_id
if permissions.has_vendor_permissions():
criterions["assigned_to"] = persons_service.get_current_user()["id"]
return shots_service.get_shots(criterions)
def test_remove_shot_with_tasks(self):
self.generate_fixture_person()
self.generate_fixture_assigner()
self.generate_fixture_department()
self.generate_fixture_task_status()
self.generate_fixture_task_type()
self.generate_fixture_shot_task()
path = "data/shots/%s" % self.shot.id
self.delete(path)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 3)
self.assertEqual(shots[2]["canceled"], True)
def get(self):
"""
Retrieve all shot entries. Filters can be specified in the query string.
"""
criterions = query.get_query_criterions_from_request(request)
if "sequence_id" in criterions:
sequence = shots_service.get_sequence(criterions["sequence_id"])
criterions["project_id"] = sequence["project_id"]
criterions["parent_id"] = sequence["id"]
del criterions["sequence_id"]
if permissions.has_vendor_permissions():
criterions["assigned_to"] = persons_service.get_current_user()["id"]
user_service.check_project_access(criterions.get("project_id", None))
return shots_service.get_shots(criterions)
def test_import_shots(self):
path = "/import/csv/projects/%s/shots" % self.project.id
file_path_fixture = self.get_fixture_file_path(
os.path.join("csv", "shots.csv"))
self.upload_file(path, file_path_fixture)
sequences = shots_service.get_sequences()
self.assertEqual(len(sequences), 3)
shots = shots_service.get_shots()
self.assertEqual(len(shots), 4)
entity_types = EntityType.query.all()
self.assertEqual(len(entity_types), 3)
def post(self, project_id, task_type_id):
user_service.check_manager_project_access(project_id)
task_type = tasks_service.get_task_type(task_type_id)
shot_ids = request.json
shots = []
if type(shot_ids) == list and len(shot_ids) > 0:
for shot_id in shot_ids:
shot = shots_service.get_shot(shot_id)
if shot["project_id"] == project_id:
shots.append(shot)
else:
criterions = query.get_query_criterions_from_request(request)
criterions["project_id"] = project_id
shots = shots_service.get_shots(criterions)
task_type = tasks_service.get_task_type(task_type_id)
tasks = tasks_service.create_tasks(task_type, shots)
return tasks, 201
def post(self, project_id, task_type_id):
"""
Create a new task for given shot and task type.
---
tags:
- Tasks
parameters:
- in: path
name: project_id
required: True
schema:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
- in: path
name: task_type_id
required: True
schema:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
responses:
201:
description: New task for given shot and task type created
"""
user_service.check_manager_project_access(project_id)
task_type = tasks_service.get_task_type(task_type_id)
shot_ids = request.json
shots = []
if type(shot_ids) == list and len(shot_ids) > 0:
for shot_id in shot_ids:
shot = shots_service.get_shot(shot_id)
if shot["project_id"] == project_id:
shots.append(shot)
else:
criterions = query.get_query_criterions_from_request(request)
criterions["project_id"] = project_id
shots = shots_service.get_shots(criterions)
task_type = tasks_service.get_task_type(task_type_id)
tasks = tasks_service.create_tasks(task_type, shots)
return tasks, 201
def prepare_import(self, project_id, task_type_id, episode_id=None):
self.organisation = Organisation.query.first()
self.assets_map = {}
self.shots_map = {}
self.tasks_map = {}
asset_types_map = {}
asset_types = assets_service.get_asset_types_for_project(project_id)
for asset_type in asset_types:
asset_types_map[asset_type["id"]] = slugify(asset_type["name"])
criterions_assets = {"project_id": project_id}
if episode_id is not None and episode_id not in ["main", "all"]:
criterions_assets["source_id"] = episode_id
assets = assets_service.get_assets(criterions_assets)
for asset in assets:
key = "%s%s" % (
asset_types_map[asset["entity_type_id"]],
slugify(asset["name"]),
)
self.assets_map[key] = asset["id"]
sequences_map = {}
criterions_sequences = {"project_id": project_id}
if episode_id is not None and episode_id not in ["main", "all"]:
criterions_sequences["parent_id"] = episode_id
sequences = shots_service.get_sequences(criterions_sequences)
for sequence in sequences:
sequences_map[sequence["id"]] = slugify(sequence["name"])
shots = shots_service.get_shots({"project_id": project_id})
for shot in shots:
sequence_key = sequences_map.get(shot["parent_id"])
if sequence_key is not None:
key = "%s%s" % (sequence_key, slugify(shot["name"]))
self.shots_map[key] = shot["id"]
for task in tasks_service.get_tasks_for_project_and_task_type(
project_id, task_type_id):
self.tasks_map[task["entity_id"]] = task["id"]
def prepare_import(self):
self.projects = {}
self.sequences = {}
self.episodes = {}
self.shots = {}
self.entity_types = {}
self.entities = {}
self.persons = {}
self.departments = {}
self.task_types = {}
self.task_statuses = {}
for project in Project.query.all():
self.projects[project.name] = project
for person in Person.query.all():
self.persons[person.first_name + " " + person.last_name] = person
for episode in shots_service.get_episodes():
self.episodes[str(episode["project_id"]) +
episode["name"]] = episode
for sequence in shots_service.get_sequences():
self.sequences["%s%s%s" %
(sequence["project_id"], sequence["parent_id"],
sequence["name"])] = sequence
for shot in shots_service.get_shots():
self.shots["%s%s%s" % (shot["project_id"], shot["parent_id"],
shot["name"])] = shot
for entity_type in EntityType.query.all():
self.entity_types[entity_type.name] = entity_type
for entity in Entity.query.all():
self.entities["%s%s%s" % (entity.project_id, entity.entity_type_id,
entity.name)] = entity
def test_get_shots(self):
shots = shots_service.get_shots()
self.shot_dict = self.shot.serialize(obj_type="Shot")
self.shot_dict["project_name"] = self.project.name
self.shot_dict["sequence_name"] = self.sequence.name
self.assertDictEqual(shots[0], self.shot_dict)
def get_shots_by_scene(scene_id):
"""
Get shots linked to a scene (of which the source is the given scene).
"""
return shots_service.get_shots({"source_id": scene_id})
