def post(self, task_id):
(name, mode, description, comment, person_id, software_id, revision,
sep) = self.get_arguments()
try:
task = tasks_service.get_task(task_id)
user_service.check_project_access(task["project_id"])
software = files_service.get_software(software_id)
tasks_service.assign_task(task_id,
persons_service.get_current_user()["id"])
if revision == 0:
revision = files_service.get_next_working_revision(
task_id, name)
path = self.build_path(task, name, revision, software, sep, mode)
working_file = files_service.create_new_working_revision(
task_id,
person_id,
software_id,
name=name,
path=path,
comment=comment,
revision=revision)
except EntryAlreadyExistsException:
return {"error": "The given working file already exists."}, 400
return working_file, 201
def post(self, entity_id):
(name, path, mode, description, comment, person_id, software_id,
revision, sep, size) = self.get_arguments()
task_id = None
# try by task
try:
task = tasks_service.get_task(entity_id)
task_id = entity_id
entity_id = task["entity_id"]
user_service.check_project_access(task["project_id"])
user_service.check_entity_access(task["entity_id"])
tasks_service.assign_task(task_id,
persons_service.get_current_user()["id"])
except:
# try by entity
entity = entities_service.get_entity(entity_id)
user_service.check_project_access(entity["project_id"])
user_service.check_entity_access(entity_id)
try:
working_file = files_service.create_new_working_revision(
person_id,
software_id,
task_id=task_id,
entity_id=entity_id,
name=name,
path=path,
comment=comment,
revision=revision,
)
except EntryAlreadyExistsException:
return {"error": "The given working file already exists."}, 400
return working_file, 201
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 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_get_tasks_for_person(self):
projects = [self.project.serialize()]
tasks = tasks_service.get_person_tasks(self.user["id"], projects)
self.assertEqual(len(tasks), 0)
tasks_service.assign_task(self.task.id, self.user["id"])
tasks = tasks_service.get_person_tasks(self.user["id"], projects)
self.assertEqual(len(tasks), 1)
tasks_service.create_comment(
self.task.id,
self.task_status.id,
self.person.id,
"first comment"
)
tasks_service.create_comment(
self.task.id,
self.task_status.id,
self.person.id,
"last comment"
)
tasks = tasks_service.get_person_tasks(self.person.id, projects)
self.assertEqual(len(tasks), 2)
self.assertEqual(tasks[1]["last_comment"]["text"], "last comment")
self.assertEqual(
tasks[1]["last_comment"]["person_id"],
str(self.person.id)
)
def test_get_notifications(self):
person_id = str(self.person.id)
tasks_service.assign_task(self.task.id, self.user.id)
self.generate_fixture_comment()
notifications_service.create_notifications_for_task_and_comment(
self.task_dict, self.comment)
path = "/data/user/notifications"
notifications = self.get(path)
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0]["author_id"], person_id)
def test_has_task_related(self):
self.log_in_cg_artist()
self.generate_fixture_entity_type()
self.generate_fixture_entity()
self.generate_assigned_task()
task_id = self.task.id
self.get("data/assets/%s" % self.entity.id, 403)
self.task = tasks_service.get_task(task_id)
tasks_service.assign_task(self.task["id"], self.user_cg_artist.id)
self.get("data/assets/%s" % self.entity.id, 200)
def test_clear_assignation(self):
task_id = str(self.task.id)
shot_task_id = str(self.shot_task.id)
tasks_service.assign_task(self.task.id, self.person.id)
tasks_service.assign_task(self.shot_task.id, self.person.id)
data = {"task_ids": [task_id, shot_task_id]}
self.put("/actions/tasks/clear-assignation", data)
task = tasks_service.get_task(task_id)
self.assertEquals(len(task["assignees"]), 0)
task = tasks_service.get_task(shot_task_id)
self.assertEquals(len(task["assignees"]), 0)
def test_get_notification(self):
tasks_service.assign_task(self.task.id, self.user.id)
self.generate_fixture_comment()
notifications_service.create_notifications_for_task_and_comment(
self.task_dict, self.comment)
path = "/data/user/notifications"
notifications = self.get(path)
notification = notifications[0]
path = "/data/user/notifications/%s" % notification["id"]
notification_again = self.get(path)
self.assertEqual(notification_again["id"], notification["id"])
self.assertEqual(notification_again["full_entity_name"],
"Props / Tree")
def test_clear_assignation(self):
self.generate_fixture_task()
self.generate_fixture_shot_task()
task_id = str(self.task.id)
shot_task_id = str(self.shot_task.id)
tasks_service.assign_task(self.task.id, self.person.id)
tasks_service.assign_task(self.shot_task.id, self.person.id)
data = {"task_ids": [task_id, shot_task_id]}
self.put("/actions/tasks/clear-assignation", data)
task = tasks_service.get_task_with_relations(task_id)
self.assertEqual(len(task["assignees"]), 0)
task = tasks_service.get_task_with_relations(shot_task_id)
self.assertEqual(len(task["assignees"]), 0)
def test_user_projects(self):
self.generate_fixture_project_standard()
self.generate_fixture_project_closed_status()
self.generate_fixture_project_closed()
self.generate_fixture_entity_type()
self.generate_fixture_entity()
self.generate_assigned_task()
tasks_service.assign_task(self.task.id, self.user_cg_artist.id)
self.log_in_cg_artist()
self.get("data/projects", 403)
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_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_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_get_done_tasks_for_person(self):
projects = [self.project.serialize()]
tasks = tasks_service.get_person_done_tasks(self.user.id, projects)
self.assertEqual(len(tasks), 0)
tasks_service.assign_task(self.task.id, self.user.id)
tasks = tasks_service.get_person_done_tasks(self.user.id, projects)
self.assertEqual(len(tasks), 0)
done_status = tasks_service.get_done_status()
tasks_service.update_task(self.task.id,
{"task_status_id": done_status["id"]})
tasks = tasks_service.get_person_done_tasks(self.user.id, projects)
self.assertEqual(len(tasks), 1)
def test_get_output_file_permission(self):
task_id = self.task.id
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)
tasks_service.assign_task(task_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 test_update_working_file_permission(self):
working_file = self.working_file.serialize()
task = self.task.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)
tasks_service.assign_task(task["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_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_get_working_file(self):
self.generate_fixture_user_cg_artist()
task_id = self.task.id
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)
tasks_service.assign_task(task_id, user_cg_artist_id)
working_file_again = self.get("data/working-files/%s" %
working_file["id"])
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 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 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.assertEquals(remote_file["id"], working_file_id)
self.assertEquals(remote_file["type"], "WorkingFile")
path = "/data/files/%s" % output_file_id
remote_file = self.get(path)
self.assertEquals(remote_file["id"], output_file_id)
self.assertEquals(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)
tasks_service.assign_task(self.task.id, self.user_cg_artist.id)
remote_file = self.get(path)
def test_assign_task(self):
tasks_service.assign_task(self.task.id, self.assigner.id)
self.assertEqual(self.task.assignees[1].id, self.assigner.id)
def assign_task(self, task_id, user_id):
return tasks_service.assign_task(task_id, user_id)
def assign_task(self, task_id, person_id):
return tasks_service.assign_task(task_id, person_id)
def assign_user(self, task_id):
tasks_service.assign_task(task_id, self.user.id)
def assign_user(self, task_id):
tasks_service.assign_task(task_id, self.user.id)
project = Project.get(self.project_id)
project.team.append(self.user)
project.save()
def test_clear_assignation(self):
task_id = self.task.id
tasks_service.assign_task(self.task.id, self.person.id)
tasks_service.clear_assignation(task_id)
task = tasks_service.get_task(task_id)
self.assertEquals(len(task["assignees"]), 0)
def assign_user(self, task_id):
tasks_service.assign_task(task_id, self.user_id)
project = Project.get(self.project_id)
person = Person.get(self.user_id)
project.team.append(person)
project.save()
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)