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 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 get(self):
"""
Retrieve all sequence entries. Filters can be specified in the query
string.
"""
criterions = query.get_query_criterions_from_request(request)
user_service.check_project_access(criterions)
return shots_service.get_sequences(criterions)
def get(self):
"""
Retrieve all sequence 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_sequences(criterions)
def get(self, episode_id):
"""
Retrieve all sequence entries for a given episode.
Filters can be specified in the query string.
"""
episode = shots_service.get_episode(episode_id)
user_service.check_project_access(episode["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = episode_id
return shots_service.get_sequences(criterions)
def get(self, episode_id):
"""
Retrieve all sequence entries for a given episode.
Filters can be specified in the query string.
"""
episode = shots_service.get_episode(episode_id)
if not permissions.has_manager_permissions():
user_service.check_has_task_related(episode["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = episode_id
return shots_service.get_sequences(criterions)
def get(self):
"""
Retrieve all sequence entries. Filters can be specified in the query
string.
"""
criterions = query.get_query_criterions_from_request(request)
if "episode_id" in criterions:
episode = shots_service.get_episode(criterions["episode_id"])
criterions["project_id"] = episode["project_id"]
criterions["parent_id"] = episode["id"]
del criterions["episode_id"]
user_service.check_project_access(criterions.get("project_id", None))
return shots_service.get_sequences(criterions)
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 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 get(self, episode_id):
"""
Retrieve all sequence entries for a given episode.
Filters can be specified in the query string.
"""
episode = shots_service.get_episode(episode_id)
user_service.check_project_access(episode["project_id"])
criterions = query.get_query_criterions_from_request(request)
criterions["parent_id"] = episode_id
if permissions.has_vendor_permissions():
return shots_service.get_sequences_for_episode(episode_id,
only_assigned=True)
else:
return shots_service.get_sequences(criterions)
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_sequences(self):
sequences = shots_service.get_sequences()
self.assertEquals(len(sequences), 1)
self.assertEquals(sequences[0]["id"], str(self.sequence.id))
def test_import_sequence_task(self):
self.load_sequence_task()
sequences = shots_service.get_sequences({"shotgun_id": 1})
self.tasks = self.get("data/tasks?entity_id=%s" % sequences[0]["id"])
self.assertEqual(len(self.tasks), 1)
def test_get_sequences(self):
sequences = shots_service.get_sequences()
self.assertDictEqual(
sequences[0],
self.sequence.serialize(obj_type="Sequence")
)
