def test_get_shot_by_name_with_vendor(self):
shot_name = self.shot.name.lower()
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()
self.generate_fixture_user_vendor()
sequence_id = str(self.sequence.id)
project_id = str(self.shot_task.project_id)
task_id = str(self.shot_task.id)
shot_id = str(self.shot.id)
vendor_id = str(self.user_vendor["id"])
self.log_in_vendor()
self.get(
"data/shots?sequence_id=%s&name=%s" % (sequence_id, shot_name), 403
)
projects_service.add_team_member(project_id, vendor_id)
shots = self.get("data/shots?sequence_id=%s&name=%s" % (
sequence_id,
shot_name
))
self.assertEqual(len(shots), 0)
tasks_service.assign_task(task_id, vendor_id)
shots = self.get("data/shots?sequence_id=%s&name=%s" % (
sequence_id,
shot_name
))
self.assertEqual(shots[0]["id"], shot_id)
def test_attachments(self):
self.delete_test_folder()
self.create_test_folder()
task_id = str(self.task.id)
project_id = str(self.project.id)
self.upload_file("/actions/tasks/%s/comment" % task_id,
self.get_fixture_file_path(
os.path.join("thumbnails", "th01.png")),
extra_fields={
"task_status_id": self.retake_status_id,
"comment": "retake 1"
})
attachment = self.get("data/attachment-files")[0]
attachment = self.get("data/attachment-files/%s" % attachment["id"])
path = "/data/attachment-files/%s/file/th01.png" % attachment["id"]
result_file_path = self.get_file_path("th01.png")
self.download_file(path, result_file_path)
result_image = Image.open(result_file_path)
self.assertEqual(result_image.size, (180, 101))
self.generate_fixture_user_vendor()
self.log_in_vendor()
self.get("data/attachment-files/%s" % attachment["id"], 403)
projects_service.add_team_member(project_id, self.user_vendor["id"])
tasks_service.assign_task(task_id, self.user_vendor["id"])
self.get("data/attachment-files/%s" % attachment["id"])
self.delete_test_folder()
def put(self, person_id):
(task_ids) = self.get_arguments()
if len(task_ids) > 0:
task = tasks_service.get_task(task_ids[0])
user_service.check_manager_project_access(task["project_id"])
tasks = []
for task_id in task_ids:
try:
task = self.assign_task(task_id, person_id)
author = persons_service.get_current_user()
notifications_service.create_assignation_notification(
task_id, person_id, author["id"]
)
tasks.append(task)
except TaskNotFoundException:
pass
except PersonNotFoundException:
return {"error": "Assignee doesn't exist in database."}, 400
if len(tasks) > 0:
projects_service.add_team_member(tasks[0]["project_id"], person_id)
return tasks
def test_remove_team_member(self):
self.generate_fixture_person()
projects_service.add_team_member(self.project.id, self.person.id)
self.delete("data/projects/%s/team/%s" %
(self.project.id, self.person.id))
project = projects_service.get_project_with_relations(self.project.id)
self.assertEqual(project["team"], [])
def test_get_untyped_file(self):
working_file_id = str(self.working_file.id)
output_file_id = str(self.output_file.id)
path = "/data/files/%s" % working_file_id
remote_file = self.get(path)
self.assertEqual(remote_file["id"], working_file_id)
self.assertEqual(remote_file["type"], "WorkingFile")
path = "/data/files/%s" % output_file_id
remote_file = self.get(path)
self.assertEqual(remote_file["id"], output_file_id)
self.assertEqual(remote_file["type"], "OutputFile")
path = "/data/files/%s" % self.task_id
self.get(path, 404)
self.generate_fixture_user_cg_artist()
self.log_in_cg_artist()
path = "/data/files/%s" % output_file_id
self.get(path, 403)
projects_service.add_team_member(
self.project_id,
self.user_cg_artist["id"]
)
self.get(path)
def test_get_tasks_permissions(self):
self.generate_fixture_user_vendor()
self.generate_fixture_user_cg_artist()
task_1_id = str(self.generate_fixture_task().id)
str(self.generate_fixture_task(name="second task").id)
str(self.generate_fixture_shot_task().id)
user_id = self.user_cg_artist["id"]
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 3)
self.log_in_cg_artist()
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 0)
projects_service.add_team_member(self.project_id, user_id)
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 3)
user_id = str(self.user_vendor["id"])
self.log_in_vendor()
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 0)
projects_service.add_team_member(self.project_id, user_id)
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 0)
tasks_service.assign_task(task_1_id, user_id)
tasks = self.get("/data/tasks/")
self.assertEqual(len(tasks), 1)
def test_update_annotations_rights(self):
self.generate_fixture_user_client()
self.generate_fixture_user_cg_artist()
projects_service.add_team_member(
self.project.id,
self.user_client["id"]
)
projects_service.add_team_member(
self.project.id,
self.user_cg_artist["id"]
)
preview_file = self.generate_fixture_preview_file().serialize()
annotations = [{
"0": [
"Path", "0 0", "0 10"
]
}]
self.log_in_client()
self.put(
"actions/preview-files/%s/update-annotations" % preview_file["id"],
{"annotations": annotations}
)
self.log_in_cg_artist()
self.put(
"actions/preview-files/%s/update-annotations" % preview_file["id"],
{"annotations": annotations},
403
)
def test_is_in_team(self):
self.log_in_cg_artist()
self.generate_fixture_asset_type()
self.generate_fixture_asset()
self.get("data/assets/%s" % self.asset.id, 403)
projects_service.add_team_member(self.project_id,
self.user_cg_artist.id)
self.get("data/assets/%s" % self.asset.id, 200)
def test_get_output_file_permission(self):
output_file_id = self.get_first("data/output-files")["id"]
self.generate_fixture_user_cg_artist()
cg_artist_id = self.user_cg_artist["id"]
self.log_in_cg_artist()
output_files = self.get("data/output-files")
self.assertEquals(len(output_files), 0)
self.get("data/output-files/%s" % output_file_id, 403)
projects_service.add_team_member(self.project_id, cg_artist_id)
self.get("data/output-files/%s" % output_file_id)
output_files = self.get("data/output-files")
self.assertEquals(len(output_files), 3)
def put(self, person_id):
"""
Assign given task lists to given person.
---
tags:
- Tasks
description: If a given task ID is wrong, it ignores it.
parameters:
- in: path
name: person_id
required: True
schema:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
- in: body
name: Task
description: List of tasks ID
schema:
type: object
required:
- task_ids
properties:
task_ids:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
responses:
200:
description: Given tasks lists assigned to given person
"""
(task_ids) = self.get_arguments()
tasks = []
current_user = persons_service.get_current_user()
for task_id in task_ids:
try:
user_service.check_task_departement_access(task_id, person_id)
task = self.assign_task(task_id, person_id, current_user["id"])
author = persons_service.get_current_user()
notifications_service.create_assignation_notification(
task_id, person_id, author["id"])
tasks.append(task)
except TaskNotFoundException:
pass
except permissions.PermissionDenied:
pass
except PersonNotFoundException:
return {"error": "Assignee doesn't exist in database."}, 400
if len(tasks) > 0:
projects_service.add_team_member(tasks[0]["project_id"], person_id)
return tasks
def test_get_metadata_columns(self):
projects_service.add_metadata_descriptor(self.project_id, "asset",
"test client", [], True)
projects_service.add_metadata_descriptor(self.project_id, "asset",
"test", [], False)
self.generate_fixture_user_client()
self.log_in_client()
projects_service.add_team_member(self.project_id,
self.user_client["id"])
context = self.get("/data/user/context")
self.assertEqual(len(context["projects"]), 1)
self.assertEqual(len(context["projects"][0]["descriptors"]), 1)
self.assertEqual(context["projects"][0]["descriptors"][0]["name"],
"test client")
def test_get_sequences_for_project_with_vendor(self):
self.generate_fixture_shot_task(name="Secondary")
self.generate_fixture_user_vendor()
task_id = self.shot_task.id
project_id = self.project_id
person_id = self.user_vendor["id"]
projects_service.clear_project_cache(str(project_id))
self.log_in_vendor()
projects_service.add_team_member(project_id, person_id)
episodes = self.get("data/projects/%s/sequences" % project_id)
self.assertEqual(len(episodes), 0)
tasks_service.assign_task(task_id, person_id)
episodes = self.get("data/projects/%s/sequences" % project_id)
self.assertEqual(len(episodes), 1)
def test_check_project_access(self):
from zou.app import app
with app.app_context():
self.generate_fixture_user_cg_artist()
self.log_in_cg_artist()
with self.assertRaises(permissions.PermissionDenied):
user_service.check_project_access(str(self.project_id))
projects_service.add_team_member(
str(self.project.id), str(self.get_current_user_raw().id))
project = projects_service.get_project_with_relations(
self.project_id)
self.assertTrue(
user_service.check_project_access(str(self.project_id)))
def test_check_entity_access(self):
from zou.app import app
self.asset_id = str(self.asset.id)
with app.app_context():
self.generate_fixture_user_vendor()
self.log_in_vendor()
person_id = str(self.get_current_user_raw().id)
projects_service.add_team_member(self.project_id, person_id)
with self.assertRaises(permissions.PermissionDenied):
user_service.check_entity_access(str(self.asset_id))
tasks_service.assign_task(self.task_id, person_id)
self.assertTrue(
user_service.check_entity_access(str(self.asset_id)))
def test_update_working_file_permission(self):
working_file = self.working_file.serialize()
self.generate_fixture_user_cg_artist()
user = self.user_cg_artist.serialize()
self.log_in_cg_artist()
comment_data = {"comment": "test working file comment"}
self.put("/actions/working-files/%s/comment" % working_file["id"],
comment_data, 403)
projects_service.add_team_member(self.project_id, user["id"])
self.put("/actions/working-files/%s/comment" % working_file["id"],
comment_data)
working_file = self.get("data/working-files/%s" % working_file["id"])
self.assertEqual(working_file["comment"], comment_data["comment"])
def test_get_working_file(self):
self.generate_fixture_user_cg_artist()
user_cg_artist_id = self.user_cg_artist["id"]
working_file = self.get_first("data/working-files")
working_file_again = self.get(
"data/working-files/%s" % working_file["id"])
self.assertEquals(working_file, working_file_again)
self.get_404("data/working-files/%s" % fields.gen_uuid())
self.log_in_cg_artist()
working_file_again = self.get(
"data/working-files/%s" % working_file["id"], 403)
projects_service.add_team_member(self.project_id, user_cg_artist_id)
working_file_again = self.get(
"data/working-files/%s" % working_file["id"])
def test_download_playlist(self):
self.generate_fixture_playlist("Playlist 1", for_client=False)
result_file_path = self.get_file_path("playlist.zip")
url_path = "/data/playlists/%s/download/zip" % self.playlist.id
self.create_test_folder()
self.download_file(url_path, result_file_path)
self.generate_fixture_user_client()
projects_service.add_team_member(self.project_id,
self.user_client["id"])
self.log_in_client()
self.download_file(url_path, result_file_path, 403)
self.generate_fixture_playlist("Playlist 2", for_client=True)
url_path = "/data/playlists/%s/download/zip" % self.playlist.id
self.download_file(url_path, result_file_path)
def put(self, task_id):
(person_id) = self.get_arguments()
try:
task = tasks_service.get_task(task_id)
user_service.check_manager_project_access(task["project_id"])
self.assign_task(task_id, person_id)
notifications_service.create_assignation_notification(
task_id, person_id)
projects_service.add_team_member(task["project_id"], person_id)
except PersonNotFoundException:
return {"error": "Assignee doesn't exist in database."}, 400
return task
def post(self, project_id):
args = self.get_args([("person_id", "", True)])
user_service.check_manager_project_access(project_id)
return (
projects_service.add_team_member(project_id, args["person_id"]),
201,
)
def test_get_shots_and_tasks_vendor(self):
self.generate_fixture_shot_task(name="Secondary")
self.generate_fixture_user_vendor()
task_id = self.shot_task.id
project_id = self.project.id
person_id = self.user_vendor["id"]
self.log_in_vendor()
shots = self.get("data/shots/with-tasks?project_id=%s" % project_id,
403)
projects_service.add_team_member(project_id, person_id)
shots = self.get("data/shots/with-tasks?project_id=%s" % project_id)
self.assertEqual(len(shots), 0)
tasks_service.assign_task(task_id, person_id)
shots = self.get("data/shots/with-tasks?project_id=%s" % project_id)
self.assertEqual(len(shots), 1)
self.assertEqual(len(shots[0]["tasks"]), 1)
self.assertTrue(str(person_id) in shots[0]["tasks"][0]["assignees"])
def test_user_projects(self):
self.generate_fixture_project_standard()
self.generate_fixture_project_closed_status()
self.generate_fixture_project_closed()
self.generate_fixture_asset_type()
self.generate_fixture_asset()
self.log_in_cg_artist()
user_id = str(self.user_cg_artist.id)
projects = self.get("data/projects")
self.assertEquals(len(projects), 0)
projects_service.add_team_member(self.project_id, user_id)
projects = self.get("data/projects")
self.assertEquals(len(projects), 1)
projects = self.get("data/projects/all")
self.assertEquals(len(projects), 1)
projects = self.get("data/projects/open")
self.assertEquals(len(projects), 1)
def test_get_episodes_for_project_with_vendor(self):
self.generate_fixture_department()
self.generate_fixture_task_status()
self.generate_fixture_person()
self.generate_fixture_assigner()
self.generate_fixture_task_type()
self.generate_fixture_shot_task(name="Secondary")
self.generate_fixture_user_vendor()
task_id = self.shot_task.id
project_id = self.project_id
person_id = self.user_vendor["id"]
projects_service.add_team_member(project_id, person_id)
self.log_in_vendor()
episodes = self.get("data/projects/%s/episodes" % project_id)
self.assertEqual(len(episodes), 0)
tasks_service.assign_task(task_id, person_id)
episodes = self.get("data/projects/%s/episodes" % project_id)
self.assertEqual(len(episodes), 1)
def put(self, task_id):
"""
Assign given task list to given person.
---
tags:
- Tasks
parameters:
- in: path
name: task_id
required: True
schema:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
- in: body
name: Person
description: Person ID
schema:
type: object
required:
- person_id
properties:
person_id:
type: UUID
example: a24a6ea4-ce75-4665-a070-57453082c25
responses:
200:
description: Given task assigned to given person
400:
description: Assignee non-existent in database
"""
(person_id) = self.get_arguments()
try:
task = tasks_service.get_task(task_id)
user_service.check_manager_project_access(task["project_id"])
self.assign_task(task_id, person_id)
notifications_service.create_assignation_notification(
task_id, person_id)
projects_service.add_team_member(task["project_id"], person_id)
except PersonNotFoundException:
return {"error": "Assignee doesn't exist in database."}, 400
return task
def test_get_last_notifications(self):
from zou.app import app
with app.app_context():
persons_service.get_current_user = self.get_current_user_artist
self.generate_fixture_user_cg_artist()
self.log_in_cg_artist()
person_id = self.user_cg_artist["id"]
projects_service.add_team_member(self.project_id, person_id)
tasks_service.assign_task(self.task_id, person_id)
notifications = user_service.get_last_notifications()
self.assertEqual(len(notifications), 0)
comments_service.create_comment(
self.user["id"],
self.task_id,
self.to_review_status_id,
"Lets go",
[],
{},
None,
)
notifications = user_service.get_last_notifications()
self.assertEqual(len(notifications), 1)
comments_service.create_comment(
self.user_client["id"],
self.task_id,
self.to_review_status_id,
"Wrong picture",
[],
{},
None,
)
notifications = user_service.get_last_notifications()
self.assertEqual(len(notifications), 2)
self.assertEqual(len(notifications[0]["comment_text"]), 0)
self.assertGreater(len(notifications[1]["comment_text"]), 0)
def post(self, project_id):
"""
Manage the people listed in a production team.
---
tags:
- Projects
parameters:
- in: path
name: project_id
required: true
schema:
type: UUID
example: 5dc235ec-125e-4ba5-b1db-604d4babc315
responses:
201:
description: Person added to production team
"""
args = self.get_args([("person_id", "", True)])
user_service.check_manager_project_access(project_id)
return (
projects_service.add_team_member(project_id, args["person_id"]),
201,
)
def test_add_team_member(self):
self.generate_fixture_person()
projects_service.add_team_member(self.project.id, self.person.id)
project = projects_service.get_project_with_relations(self.project.id)
self.assertEqual(project["team"], [str(self.person.id)])
def setUp(self):
super(PreviewFileTestCase, self).setUp()
self.generate_fixture_user_cg_artist()
self.user_cg_artist_id = self.user_cg_artist["id"]
self.generate_fixture_user_vendor()
self.user_vendor_id = self.user_vendor["id"]
self.generate_fixture_person()
self.generate_fixture_assigner()
# Create first project
self.generate_fixture_project_status()
self.project1 = self.generate_fixture_project()
self.generate_fixture_asset_type()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_asset()
self.generate_fixture_sequence()
self.generate_fixture_shot()
# Create a task with one preview file
self.task1_1 = self.generate_fixture_task(name="PROJ1_TASK1")
self.generate_fixture_file_status()
self.generate_fixture_output_type()
self.generate_fixture_output_file()
self.preview_file1_1 = self.generate_fixture_preview_file(
name="PROJ1_TASK1_PF1")
# Create a task with one preview file
self.task1_2 = self.generate_fixture_task(name="PROJ1_TASK2")
self.generate_fixture_preview_file(name="PROJ1_TASK2_PF1")
# Create second project
self.generate_fixture_project_closed_status()
self.project2 = self.generate_fixture_project("test")
self.generate_fixture_asset()
self.generate_fixture_sequence()
self.generate_fixture_shot()
# Create a task with one preview file
self.task2_1 = self.generate_fixture_task(name="PROJ2_TASK1")
self.preview_file2_1 = self.generate_fixture_preview_file(
name="PROJ2_TASK1_PF1")
# Create a task with three preview files
self.task2_2 = self.generate_fixture_task(name="PROJ2_TASK2")
self.preview_file2_2 = self.generate_fixture_preview_file(
name="PROJ2_TASK2_PF1")
self.generate_fixture_preview_file(name="PROJ2_TASK2_PF2")
self.generate_fixture_preview_file(name="PROJ2_TASK2_PF3")
# Assign task 1 from project 1 to artist
projects_service.add_team_member(self.project1.id,
self.user_cg_artist_id)
tasks_service.assign_task(self.task1_1.id, self.user_cg_artist_id)
# Assign task 2 from project 2 to vendor
projects_service.add_team_member(self.project2.id, self.user_vendor_id)
tasks_service.assign_task(self.task2_2.id, self.user_vendor_id)
def test_remove_team_member(self):
self.generate_fixture_person()
projects_service.add_team_member(self.project.id, self.person.id)
projects_service.remove_team_member(self.project.id, self.person.id)
project = projects_service.get_project(self.project.id)
self.assertEqual(project["team"], [])
