def remove_person(person_id, force=True):
person = Person.get(person_id)
if force:
for comment in Comment.get_all_by(person_id=person_id):
remove_comment(comment.id)
comments = Comment.query.filter(
Comment.acknowledgements.contains(person))
for comment in comments:
comment.acknowledgements = [
member for member in comment.acknowledgements
if str(member.id) != person_id
]
comment.save()
ApiEvent.delete_all_by(user_id=person_id)
Notification.delete_all_by(person_id=person_id)
SearchFilter.delete_all_by(person_id=person_id)
DesktopLoginLog.delete_all_by(person_id=person_id)
LoginLog.delete_all_by(person_id=person_id)
Subscription.delete_all_by(person_id=person_id)
TimeSpent.delete_all_by(person_id=person_id)
for project in Project.query.filter(Project.team.contains(person)):
project.team = [
member for member in project.team
if str(member.id) != person_id
]
project.save()
for task in Task.query.filter(Task.assignees.contains(person)):
task.assignees = [
assignee for assignee in task.assignees
if str(assignee.id) != person_id
]
task.save()
for task in Task.get_all_by(assigner_id=person_id):
task.update({"assigner_id": None})
for output_file in OutputFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
for working_file in WorkingFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
for task in WorkingFile.get_all_by(person_id=person_id):
output_file.update({"person_id": None})
try:
person.delete()
events.emit("person:delete", {"person_id": person.id})
except IntegrityError:
raise ModelWithRelationsDeletionException(
"Some data are still linked to given person.")
return person.serialize_safe()
def remove_task(task_id, force=False):
"""
Remove given task. Force deletion if the task has some comments and files
related. This will lead to the deletion of all of them.
"""
task = Task.get(task_id)
if force:
working_files = WorkingFile.query.filter_by(task_id=task_id)
for working_file in working_files:
output_files = OutputFile.query.filter_by(
source_file_id=working_file.id
)
for output_file in output_files:
output_file.delete()
working_file.delete()
comments = Comment.query.filter_by(object_id=task_id)
for comment in comments:
notifications = Notification.query.filter_by(comment_id=comment.id)
for notification in notifications:
notification.delete()
news_list = News.query.filter_by(comment_id=comment.id)
for news in news_list:
news.delete()
comment.delete()
subscriptions = Subscription.query.filter_by(task_id=task_id)
for subscription in subscriptions:
subscription.delete()
preview_files = PreviewFile.query.filter_by(task_id=task_id)
for preview_file in preview_files:
remove_preview_file(preview_file)
time_spents = TimeSpent.query.filter_by(task_id=task_id)
for time_spent in time_spents:
time_spent.delete()
notifications = Notification.query.filter_by(task_id=task_id)
for notification in notifications:
notification.delete()
news_list = News.query.filter_by(task_id=task.id)
for news in news_list:
news.delete()
task.delete()
events.emit("task:delete", {"task_id": task_id})
return task.serialize()
def reset_task_data(task_id):
task = Task.get(task_id)
retake_count = 0
real_start_date = None
last_comment_date = None
end_date = None
task_status_id = TaskStatus.get_by(short_name="todo").id
comments = (Comment.query.join(TaskStatus).filter(
Comment.object_id == task_id).order_by(Comment.created_at).add_columns(
TaskStatus.is_retake, TaskStatus.is_done,
TaskStatus.short_name).all())
previous_is_retake = False
for (
comment,
task_status_is_retake,
task_status_is_done,
task_status_short_name,
) in comments:
if task_status_is_retake and not previous_is_retake:
retake_count += 1
previous_is_retake = task_status_is_retake
if task_status_short_name.lower() == "wip" and real_start_date is None:
real_start_date = comment.created_at
if task_status_is_done:
end_date = comment.created_at
else:
end_date = None
task_status_id = comment.task_status_id
last_comment_date = comment.created_at
duration = 0
time_spents = TimeSpent.get_all_by(task_id=task.id)
for time_spent in time_spents:
duration += time_spent.duration
task.update({
"duration": duration,
"retake_count": retake_count,
"real_start_date": real_start_date,
"last_comment_date": last_comment_date,
"end_date": end_date,
"task_status_id": task_status_id,
})
events.emit("task:update", {"task_id": task.id})
return task.serialize()
def create_or_update_time_spent(task_id, person_id, date, duration, add=False):
"""
Create a new time spent if it doesn't exist. If it exists, it update it
with the new duratin and returns it from the database.
"""
try:
time_spent = TimeSpent.get_by(
task_id=task_id, person_id=person_id, date=date
)
except DataError:
raise WrongDateFormatException
task = Task.get(task_id)
project_id = str(task.project_id)
if time_spent is not None:
if duration == 0:
time_spent.delete()
elif add:
time_spent.update({"duration": time_spent.duration + duration})
else:
time_spent.update({"duration": duration})
events.emit(
"time-spent:update",
{"time_spent_id": str(time_spent.id)},
project_id=project_id
)
else:
time_spent = TimeSpent.create(
task_id=task_id, person_id=person_id, date=date, duration=duration
)
events.emit(
"time-spent:new",
{"time_spent_id": str(time_spent.id)},
project_id=project_id
)
task.duration = 0
time_spents = TimeSpent.get_all_by(task_id=task_id)
for time_spent in time_spents:
task.duration += time_spent.duration
task.save()
clear_task_cache(task_id)
events.emit(
"task:update",
{"task_id": task_id},
project_id=project_id
)
return time_spent.serialize()
def test_serialize_orm_array(self):
person = Person(id=uuid.uuid4(), first_name="Jhon", last_name="Doe")
person2 = Person(id=uuid.uuid4(), first_name="Emma", last_name="Peel")
task = Task(id=uuid.uuid4(),
name="Test Task",
assignees=[person, person2])
is_id = str(person.id) in fields.serialize_orm_arrays(task.assignees)
self.assertTrue(is_id)
is_id = str(person2.id) in fields.serialize_orm_arrays(task.assignees)
self.assertTrue(is_id)
is_id = str(person.id) in fields.serialize_value(task.assignees)
self.assertTrue(is_id)
is_id = str(person2.id) in fields.serialize_value(task.assignees)
self.assertTrue(is_id)
def test_status_to_wip(self):
events.register(
"task:start",
"mark_event_as_fired",
self
)
now = datetime.datetime.now()
self.task.update({"real_start_date": None})
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.wip_status_id)
self.assertGreater(task.real_start_date.isoformat(), now.isoformat())
self.assert_event_is_fired()
def test_get_preview_files_for_vendor(self):
"""
Test route data/preview-files for vendor.
The vendor can only access the tasks he's working on.
"""
route = "data/preview-files"
self.log_in_vendor()
preview_files_vendor = self.get(route)
for preview_file in preview_files_vendor:
# tasks_service.get_task doesn't contain assignees, thus we use Task class
task = Task.get(preview_file["task_id"])
assignees_ids = [str(assignee.id) for assignee in task.assignees]
self.assertIn(self.user_vendor_id, assignees_ids)
self.assertEqual(len(preview_files_vendor), 3)
def test_get_preview_file_for_vendor(self):
"""
Test route data/preview-files/<preview_file_id> for vendor.
The vendor can only access the tasks he's working on.
"""
route2_1 = "data/preview-files/%s" % str(self.preview_file2_1.id)
route2_2 = "data/preview-files/%s" % str(self.preview_file2_2.id)
self.log_in_vendor()
preview_file_vendor = self.get(route2_2)
# tasks_service.get_task doesn't contain assignees, thus we use Task class
task = Task.get(preview_file_vendor["task_id"])
assignees_ids = [str(assignee.id) for assignee in task.assignees]
self.assertIn(self.user_vendor_id, assignees_ids)
self.get(route2_1, code=403)
def create_task(task_type, entity, name="main"):
"""
Create a new task for given task type and entity.
"""
task_status = get_todo_status()
try:
try:
current_user_id = persons_service.get_current_user()["id"]
except RuntimeError:
current_user_id = None
task = Task.create(
name=name,
duration=0,
estimation=0,
completion_rate=0,
start_date=None,
end_date=None,
due_date=None,
real_start_date=None,
project_id=entity["project_id"],
task_type_id=task_type["id"],
task_status_id=task_status["id"],
entity_id=entity["id"],
assigner_id=current_user_id,
assignees=[],
)
task_dict = task.serialize(relations=True)
task_dict.update(
{
"task_status_id": task_status["id"],
"task_status_name": task_status["name"],
"task_status_short_name": task_status["short_name"],
"task_status_color": task_status["color"],
"task_type_id": task_type["id"],
"task_type_name": task_type["name"],
"task_type_color": task_type["color"],
"task_type_priority": task_type["priority"],
}
)
events.emit(
"task:new",
{"task_id": task.id},
project_id=entity["project_id"]
)
return task_dict
except IntegrityError:
pass # Tasks already exists, no need to create it.
def generate_fixture_task_standard(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task_standard = Task.create(name="Super modeling",
project_id=self.project_standard.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.asset_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
def generate_fixture_edit_task(self, name="Edit", task_type_id=None):
if task_type_id is None:
task_type_id = self.task_type_edit.id
self.edit_task = Task.create(
name=name,
project_id=self.project.id,
task_type_id=task_type_id,
task_status_id=self.task_status.id,
entity_id=self.edit.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
self.project.team.append(self.person)
self.project.save()
return self.edit_task
def test_import_version(self):
sg_version = {
"code": "S01_Animation",
"description": "description test",
"id": 2,
"user": {"id": 1, "name": "Jhon Doe", "type": "HumanUser"},
"entity": {"id": 1, "name": "SH01", "type": "Shot"},
"project": {"id": 1, "name": "Cosmos Landromat", "type": "Project"},
"sg_task": {"id": 1, "name": "Animation", "type": "Task"},
"sg_uploaded_movie": {
"content_type": "video/mp4",
"id": 1,
"link_type": "upload",
"name": "movie_new.mp4",
"type": "Attachment",
"url": "https://sg-media.amazonaws.com/9e73/movie_new.mp4",
},
"type": "Version",
}
api_path = "/import/shotgun/versions"
self.preview_files = self.post(api_path, [sg_version], 200)
self.assertEqual(len(self.preview_files), 1)
self.preview_files = self.get("data/preview-files")
self.assertEqual(len(self.preview_files), 1)
preview_file = self.preview_files[0]
task = Task.get_by(shotgun_id=sg_version["sg_task"]["id"])
person = Person.get_by(shotgun_id=sg_version["user"]["id"])
self.assertEqual(preview_file["name"], sg_version["code"])
self.assertEqual(preview_file["source"], "Shotgun")
self.assertEqual(preview_file["task_id"], str(task.id))
self.assertEqual(preview_file["name"], sg_version["code"])
self.assertEqual(preview_file["description"], sg_version["description"])
self.assertEqual(preview_file["shotgun_id"], sg_version["id"])
self.assertEqual(
preview_file["uploaded_movie_url"],
sg_version["sg_uploaded_movie"]["url"],
)
self.assertEqual(
preview_file["uploaded_movie_url"],
sg_version["sg_uploaded_movie"]["url"],
)
self.assertEqual(preview_file["person_id"], str(person.id))
def create_new_working_revision(
person_id,
software_id,
entity_id=None,
task_id=None,
name="main",
path="",
comment="",
revision=0,
):
"""
Create a new working file revision for given task. An author (user) and
a software are required.
"""
if task_id:
task = Task.get(task_id)
entity_id = task.entity_id
if revision == 0:
revision = get_next_working_revision(name, task_id=task_id, entity_id=entity_id)
if path:
previous_working_file = get_working_file_by_path(path)
if previous_working_file:
return previous_working_file.serialize()
try:
working_file = WorkingFile.create(
comment=comment,
name=name,
revision=revision,
path=path,
task_id=task_id,
software_id=software_id,
entity_id=entity_id,
person_id=person_id,
)
events.emit(
"working_file:new",
{"working_file_id": working_file.id},
project_id=str(task.project_id)
)
except IntegrityError:
raise EntryAlreadyExistsException
return working_file.serialize()
def test_publish_task(self):
handler = ToReviewHandler(self.open_status_id,
self.to_review_status_id)
events.register("task:to-review", "mark_event_as_fired", handler)
tasks_service.task_to_review(self.task.id, self.person.serialize(),
"my comment")
self.is_event_fired = handler.is_event_fired
data = handler.data
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.to_review_status_id)
self.assert_event_is_fired()
self.assertEquals(data["previous_task_status_id"],
str(self.open_status_id))
self.assertEquals(data["comment"], "my comment")
def update_preview_file(preview_file_id, data, silent=False):
try:
preview_file = files_service.get_preview_file_raw(preview_file_id)
except:
# Dirty hack because sometimes the preview file retrieval crashes.
time.sleep(1)
preview_file = files_service.get_preview_file_raw(preview_file_id)
preview_file.update(data)
files_service.clear_preview_file_cache(preview_file_id)
if not silent:
task = Task.get(preview_file.task_id)
events.emit(
"preview-file:update",
{"preview_file_id": preview_file_id},
project_id=str(task.project_id),
)
return preview_file.serialize()
def guess_task(entity, task_type, task_name):
if entity is None:
raise WrongPathFormatException(
"No asset or shot found in given path."
)
criterions = {
"entity_id": entity.id,
"task_type_id": task_type.id
}
if len(task_name) > 0:
criterions["name"] = task_name
task = Task.get_by(**criterions)
if task is None:
raise TaskNotFoundException
else:
return task
def test_import_note(self):
self.load_note()
self.assertEqual(len(self.notes), 1)
self.comments = self.get("data/comments")
self.assertEqual(len(self.comments), 1)
note = self.comments[0]
task = Task.get_by(shotgun_id=self.sg_note["tasks"][0]["id"])
person = Person.get_by(shotgun_id=self.sg_note["user"]["id"])
self.assertEqual(note["text"], self.sg_note["content"])
self.assertEqual(note["object_type"], "Task")
self.assertEqual(note["shotgun_id"], self.sg_note["id"])
self.assertEqual(note["object_id"], str(task.id))
self.assertEqual(note["person_id"], str(person.id))
self.assertEqual(note["created_at"][:19],
self.sg_note["created_at"][:19])
def import_entry(self, data):
task = Task.get_by(shotgun_id=data["shotgun_id"])
if task is None:
task = Task.get_by(
name=data["name"],
project_id=data["project_id"],
task_type_id=data["task_type_id"],
entity_id=data["entity_id"]
)
if task is None:
task = Task(**data)
task.save()
current_app.logger.info("Task created: %s" % task)
else:
task.update(data)
current_app.logger.info("Task updated: %s" % task)
return task
def generate_fixture_task(self, name="Master", asset_id=None):
if asset_id is None:
asset_id = self.asset.id
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task = Task.create(name=name,
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=asset_id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
return self.task
def remove_preview_file(preview_file):
"""
Remove all files related to given preview file, then remove the preview file
entry from the database.
"""
task = Task.get(preview_file.task_id)
entity = Entity.get(task.entity_id)
if entity.preview_file_id == preview_file.id:
entity.update({"preview_file_id": None})
if preview_file.extension == "png":
clear_picture_files(preview_file.id)
elif preview_file.extension == "mp4":
clear_movie_files(preview_file.id)
else:
clear_generic_files(preview_file.id)
preview_file.comments = []
preview_file.save()
preview_file.delete()
return preview_file.serialize()
def refresh_shot_casting_stats(shot, priority_map=None):
"""
For all tasks related to given shot, it computes how many assets are
available for this task and saves the result on the task level.
"""
if priority_map is None:
priority_map = _get_task_type_priority_map(shot["project_id"])
casting = get_entity_casting(shot["id"])
tasks = Task.get_all_by(entity_id=shot["id"])
for task in tasks:
nb_ready = 0
for asset in casting:
if _is_asset_ready(asset, task, priority_map):
nb_ready += 1
task.update({"nb_assets_ready": nb_ready})
events.emit("task:update-casting-stats", {
"task_id": str(task.id),
"nb_assets_ready": nb_ready
},
persist=False,
project_id=shot["project_id"])
def add_preview_file_to_comment(comment_id, person_id, task_id, revision=0):
"""
Add a preview to comment preview list. Auto set the revision field
(add 1 if it's a new preview, keep the preview revision in other cases).
"""
comment = get_comment_raw(comment_id)
news = News.get_by(comment_id=comment_id)
task = Task.get(comment.object_id)
project_id = str(task.project_id)
position = 1
if revision == 0 and len(comment.previews) == 0:
revision = get_next_preview_revision(task_id)
elif revision == 0:
revision = comment.previews[0].revision
position = get_next_position(task_id, revision)
else:
position = get_next_position(task_id, revision)
preview_file = files_service.create_preview_file_raw(str(
uuid.uuid4())[:13],
revision,
task_id,
person_id,
position=position)
events.emit(
"preview-file:new",
{
"preview_file_id": preview_file.id,
"comment_id": comment_id,
},
project_id=project_id,
)
comment.previews.append(preview_file)
comment.save()
if news is not None:
news.update({"preview_file_id": preview_file.id})
events.emit("comment:update", {"comment_id": comment.id},
project_id=project_id)
return preview_file.serialize()
def remove_task(task_id, force=False):
"""
Remove given task. Force deletion if the task has some comments and files
related. This will lead to the deletion of all of them.
"""
task = Task.get(task_id)
entity = Entity.get(task.entity_id)
if force:
working_files = WorkingFile.query.filter_by(task_id=task_id)
for working_file in working_files:
output_files = OutputFile.query.filter_by(
source_file_id=working_file.id)
for output_file in output_files:
output_file.delete()
working_file.delete()
comments = Comment.query.filter_by(object_id=task_id)
for comment in comments:
notifications = Notification.query.filter_by(comment_id=comment.id)
for notification in notifications:
notification.delete()
comment.delete()
subscriptions = Subscription.query.filter_by(task_id=task_id)
for subscription in subscriptions:
subscription.delete()
preview_files = PreviewFile.query.filter_by(task_id=task_id)
for preview_file in preview_files:
if entity.preview_file_id == preview_file.id:
entity.update({"preview_file_id": None})
remove_preview_file(preview_file)
task.delete()
events.emit("task:deletion", {"task_id": task_id})
return task.serialize()
def remove_comment(comment_id):
"""
Remove a comment from database and everything related (notifs, news, and
preview files)
"""
comment = Comment.get(comment_id)
if comment is not None:
task = Task.get(comment.object_id)
notifications = Notification.query.filter_by(comment_id=comment.id)
for notification in notifications:
notification.delete()
news_list = News.query.filter_by(comment_id=comment.id)
for news in news_list:
news.delete()
if comment.preview_file_id is not None:
preview_file = PreviewFile.get(comment.preview_file_id)
comment.preview_file_id = None
comment.save()
remove_preview_file(preview_file)
previews = [preview for preview in comment.previews]
comment.delete()
for preview in previews:
remove_preview_file(preview)
if task is not None:
events.emit(
"comment:delete",
{"comment_id": comment.id},
project_id=str(task.project_id),
)
return comment.serialize()
else:
raise CommentNotFoundException
class TaskServiceTestCase(ApiDBTestCase):
def setUp(self):
super(TaskServiceTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_asset_type()
self.generate_fixture_asset()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_task_status_wip()
self.generate_fixture_task_status_to_review()
self.generate_fixture_person()
self.generate_fixture_assigner()
self.generate_fixture_task()
self.generate_fixture_shot_task()
self.generate_fixture_file_status()
self.generate_fixture_software()
self.generate_fixture_working_file()
self.generate_fixture_output_type()
self.generate_fixture_output_file()
self.task_id = self.task.id
self.open_status_id = self.task_status.id
self.wip_status_id = self.task_status_wip.id
self.to_review_status_id = self.task_status_to_review.id
self.is_event_fired = False
events.unregister_all()
def handle_event(self, data):
self.is_event_fired = True
self.assertEqual(data["previous_task_status_id"],
str(self.open_status_id))
def assert_event_is_fired(self):
self.assertTrue(self.is_event_fired)
def test_get_status(self):
task_status = tasks_service.get_or_create_status("WIP", "wip")
self.assertEqual(task_status["name"], "WIP")
def test_get_wip_status(self):
task_status = tasks_service.get_wip_status()
self.assertEqual(task_status["name"], "WIP")
def test_get_done_status(self):
task_status = tasks_service.get_done_status()
self.assertEqual(task_status["name"], "Done")
def test_get_todo_status(self):
task_status = tasks_service.get_todo_status()
self.assertEqual(task_status["name"], "Todo")
def test_get_to_review_status(self):
task_status = tasks_service.get_to_review_status()
self.assertEqual(task_status["name"], "To review")
def test_create_task(self):
shot = self.shot.serialize()
task_type = self.task_type.serialize()
status = tasks_service.get_todo_status()
task = tasks_service.create_task(task_type, shot)
task = tasks_service.get_task(task["id"])
self.assertEquals(task["entity_id"], shot["id"])
self.assertEquals(task["task_type_id"], task_type["id"])
self.assertEquals(task["project_id"], shot["project_id"])
self.assertEquals(task["task_status_id"], status["id"])
def test_status_to_wip(self):
events.register("task:start", "mark_event_as_fired", self)
now = datetime.datetime.now()
self.task.update({"real_start_date": None})
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.wip_status_id)
self.assertGreater(task.real_start_date.isoformat(), now.isoformat())
self.assert_event_is_fired()
def test_status_to_wip_twice(self):
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
real_start_date = task.real_start_date
task.update({"task_status_id": self.task_status.id})
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
self.assertEqual(task.real_start_date, real_start_date)
def test_publish_task(self):
handler = ToReviewHandler(self.open_status_id,
self.to_review_status_id)
events.register("task:to-review", "mark_event_as_fired", handler)
tasks_service.task_to_review(self.task.id, self.person.serialize(),
"my comment")
self.is_event_fired = handler.is_event_fired
data = handler.data
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.to_review_status_id)
self.assert_event_is_fired()
self.assertEquals(data["previous_task_status_id"],
str(self.open_status_id))
self.assertEquals(data["comment"], "my comment")
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 test_get_department_from_task(self):
department = tasks_service.get_department_from_task(self.task.id)
self.assertEqual(department["name"], "Modeling")
def test_get_task(self):
self.assertRaises(TaskNotFoundException, tasks_service.get_task,
"wrong-id")
task = tasks_service.get_task(self.task_id)
self.assertEqual(str(self.task_id), task["id"])
self.output_file.delete()
self.working_file.delete()
tasks_service.remove_task(task["id"])
self.assertRaises(TaskNotFoundException, tasks_service.get_task,
self.task_id)
def test_get_tasks_for_sequence(self):
self.generate_fixture_sequence_task()
tasks = tasks_service.get_tasks_for_sequence(self.sequence.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.sequence_task.id))
def test_get_tasks_for_shot(self):
tasks = tasks_service.get_tasks_for_shot(self.shot.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.shot_task.id))
def test_get_tasks_for_scene(self):
self.generate_fixture_scene()
self.generate_fixture_scene_task()
tasks = tasks_service.get_tasks_for_scene(self.scene.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.scene_task.id))
def test_get_dict_tasks_for_asset(self):
tasks = tasks_service.get_task_dicts_for_entity(self.asset.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.task.id))
self.assertEqual(tasks[0]["task_type_name"], str("Shaders"))
self.assertEqual(tasks[0]["entity_name"], str("Tree"))
def test_get_task_types_for_shot(self):
task_types = tasks_service.get_task_types_for_shot(self.shot.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_scene(self):
self.generate_fixture_scene()
self.generate_fixture_scene_task()
task_types = tasks_service.get_task_types_for_scene(self.scene.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_sequence(self):
self.generate_fixture_sequence_task()
task_types = tasks_service.get_task_types_for_sequence(
self.sequence.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_entity(self):
task_types = tasks_service.get_task_types_for_entity(self.asset.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type.id))
def test_get_task_dicts_for_entity_utf8(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.working_file.delete()
self.output_file.delete()
self.task.delete()
self.task_type = TaskType(name="Modélisation",
color="#FFFFFF",
department_id=self.department.id)
self.task_type.save()
self.task = Task(name="Première Tâche",
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.asset.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task.save()
tasks = tasks_service.get_task_dicts_for_entity(self.asset.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["name"], u"Première Tâche")
self.assertEqual(tasks[0]["task_type_name"], u"Modélisation")
def test_get_or_create_time_spents(self):
person_id = self.person.id
task_id = self.task.id
duration = 3600
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration)
self.assertEquals(time_spent["duration"], duration)
duration = 7200
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration)
self.assertEquals(time_spent["duration"], duration)
duration = 7200
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration,
add=True)
self.assertEquals(time_spent["duration"], 2 * duration)
def test_get_time_spents(self):
person_id = self.person.id
user_id = self.user.id
task_id = self.task.id
TimeSpent.create(person_id=person_id,
task_id=task_id,
date=datetime.date(2017, 9, 23),
duration=3600)
TimeSpent.create(person_id=user_id,
task_id=task_id,
date=datetime.date(2017, 9, 23),
duration=7200)
time_spents = self.get("/actions/tasks/%s/time-spents/2017-09-23/" %
task_id)
self.assertEquals(time_spents["total"], 10800)
self.assertEquals(time_spents[str(user_id)]["duration"], 7200)
self.assertEquals(time_spents[str(person_id)]["duration"], 3600)
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 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_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_update_task(self):
done_status = tasks_service.get_done_status()
tasks_service.update_task(self.task.id,
{"task_status_id": done_status["id"]})
self.assertEquals(str(self.task.task_status_id), done_status["id"])
self.assertIsNotNone(self.task.end_date)
self.assertLess(self.task.end_date, datetime.datetime.now())
def test_remove_task(self):
self.working_file.delete()
self.output_file.delete()
tasks_service.remove_task(self.task_id)
self.assertRaises(TaskNotFoundException, tasks_service.get_task,
self.task_id)
def test_remove_task_force(self):
tasks_service.create_comment(self.task.id, self.task_status.id,
self.person.id, "first comment")
tasks_service.remove_task(self.task_id, force=True)
self.assertRaises(TaskNotFoundException, tasks_service.get_task,
self.task_id)
def is_note_linked_to_task(self, sg_note):
if len(sg_note["tasks"]) == 0:
return False
task = Task.get_by(shotgun_id=sg_note["tasks"][0]["id"])
return task is not None
class TaskServiceTestCase(ApiDBTestCase):
def setUp(self):
super(TaskServiceTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_asset_type()
self.generate_fixture_asset()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_task_status_wip()
self.generate_fixture_task_status_to_review()
self.generate_fixture_person()
self.generate_fixture_assigner()
self.generate_fixture_task()
self.generate_fixture_shot_task()
self.generate_fixture_file_status()
self.generate_fixture_software()
self.generate_fixture_working_file()
self.generate_fixture_output_type()
self.generate_fixture_output_file()
self.project_id = str(self.project.id)
self.task_id = str(self.task.id)
self.open_status_id = self.task_status.id
self.wip_status_id = self.task_status_wip.id
self.to_review_status_id = self.task_status_to_review.id
self.is_event_fired = False
events.unregister_all()
def handle_event(self, data):
self.is_event_fired = True
self.assertEqual(
data["previous_task_status_id"], str(self.open_status_id)
)
def assert_event_is_fired(self):
self.assertTrue(self.is_event_fired)
def test_get_status(self):
task_status = tasks_service.get_or_create_status("WIP", "wip")
self.assertEqual(task_status["name"], "WIP")
def test_get_wip_status(self):
task_status = tasks_service.get_wip_status()
self.assertEqual(task_status["name"], "WIP")
def test_get_done_status(self):
task_status = tasks_service.get_done_status()
self.assertEqual(task_status["name"], "Done")
def test_get_todo_status(self):
task_status = tasks_service.get_todo_status()
self.assertEqual(task_status["name"], "Todo")
def test_get_to_review_status(self):
task_status = tasks_service.get_to_review_status()
self.assertEqual(task_status["name"], "To review")
def test_create_task(self):
shot = self.shot.serialize()
task_type = self.task_type.serialize()
status = tasks_service.get_todo_status()
task = tasks_service.create_task(task_type, shot)
task = tasks_service.get_task(task["id"])
self.assertEqual(task["entity_id"], shot["id"])
self.assertEqual(task["task_type_id"], task_type["id"])
self.assertEqual(task["project_id"], shot["project_id"])
self.assertEqual(task["task_status_id"], status["id"])
def test_create_tasks(self):
shot = self.shot.serialize()
shot_2 = self.generate_fixture_shot("S02").serialize()
task_type = self.task_type.serialize()
status = tasks_service.get_todo_status()
tasks = tasks_service.create_tasks(task_type, [shot, shot_2])
self.assertEqual(len(tasks), 2)
task = tasks[0]
task = tasks_service.get_task(task["id"])
self.assertEqual(task["entity_id"], shot["id"])
self.assertEqual(task["task_type_id"], task_type["id"])
self.assertEqual(task["project_id"], shot["project_id"])
self.assertEqual(task["task_status_id"], status["id"])
def test_status_to_wip(self):
events.register("task:start", "mark_event_as_fired", self)
now = datetime.datetime.now()
self.task.update({"real_start_date": None})
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.wip_status_id)
self.assertGreater(task.real_start_date.isoformat(), now.isoformat())
self.assert_event_is_fired()
def test_status_to_wip_twice(self):
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
real_start_date = task.real_start_date
task.update({"task_status_id": self.task_status.id})
tasks_service.start_task(self.task.id)
task = Task.get(self.task.id)
self.assertEqual(task.real_start_date, real_start_date)
def test_publish_task(self):
handler = ToReviewHandler(
self.open_status_id, self.to_review_status_id
)
events.register("task:to-review", "mark_event_as_fired", handler)
tasks_service.task_to_review(
self.task.id, self.person.serialize(), "my comment"
)
self.is_event_fired = handler.is_event_fired
data = handler.data
task = Task.get(self.task.id)
self.assertEqual(task.task_status_id, self.to_review_status_id)
self.assert_event_is_fired()
self.assertEqual(
data["previous_task_status_id"], str(self.open_status_id)
)
self.assertEqual(data["comment"], "my comment")
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 test_get_department_from_task(self):
department = tasks_service.get_department_from_task(self.task.id)
self.assertEqual(department["name"], "Modeling")
def test_get_task(self):
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, "wrong-id"
)
task = tasks_service.get_task(self.task_id)
self.assertEqual(str(self.task_id), task["id"])
self.output_file.delete()
self.working_file.delete()
deletion_service.remove_task(task["id"])
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, str(self.task_id)
)
def test_get_tasks_for_sequence(self):
self.generate_fixture_sequence_task()
tasks = tasks_service.get_tasks_for_sequence(self.sequence.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.sequence_task.id))
def test_get_tasks_for_shot(self):
tasks = tasks_service.get_tasks_for_shot(self.shot.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.shot_task.id))
def test_get_tasks_for_scene(self):
self.generate_fixture_scene()
self.generate_fixture_scene_task()
tasks = tasks_service.get_tasks_for_scene(self.scene.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.scene_task.id))
def test_get_dict_tasks_for_asset(self):
tasks = tasks_service.get_task_dicts_for_entity(self.asset.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["id"], str(self.task.id))
self.assertEqual(tasks[0]["task_type_name"], str("Shaders"))
self.assertEqual(tasks[0]["entity_name"], str("Tree"))
def test_get_task_types_for_shot(self):
task_types = tasks_service.get_task_types_for_shot(self.shot.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_scene(self):
self.generate_fixture_scene()
self.generate_fixture_scene_task()
task_types = tasks_service.get_task_types_for_scene(self.scene.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_sequence(self):
self.generate_fixture_sequence_task()
task_types = tasks_service.get_task_types_for_sequence(
self.sequence.id
)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type_animation.id))
def test_get_task_types_for_entity(self):
task_types = tasks_service.get_task_types_for_entity(self.asset.id)
self.assertEqual(len(task_types), 1)
self.assertEqual(task_types[0]["id"], str(self.task_type.id))
def test_get_task_dicts_for_entity_utf8(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.working_file.delete()
self.output_file.delete()
self.task.delete()
self.task_type = TaskType(
name="Modélisation",
color="#FFFFFF",
department_id=self.department.id,
)
self.task_type.save()
self.task = Task(
name="Première Tâche",
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.asset.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date,
)
self.task.save()
tasks = tasks_service.get_task_dicts_for_entity(self.asset.id)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]["name"], u"Première Tâche")
self.assertEqual(tasks[0]["task_type_name"], u"Modélisation")
def test_get_or_create_time_spents(self):
person_id = self.person.id
task_id = self.task.id
duration = 3600
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration,
)
self.assertEqual(time_spent["duration"], duration)
duration = 7200
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration,
)
self.assertEqual(time_spent["duration"], duration)
duration = 7200
time_spent = tasks_service.create_or_update_time_spent(
person_id=person_id,
task_id=task_id,
date="2017-09-23",
duration=duration,
add=True,
)
self.assertEqual(time_spent["duration"], 2 * duration)
def test_get_time_spents(self):
pass
"""
person_id = self.person.id
user_id = self.user["id"]
task_id = self.task.id
ts1 = TimeSpent.create(
person_id=person_id,
task_id=task_id,
date=datetime.date(2017, 9, 23),
duration=3600
)
ts2 = TimeSpent.create(
person_id=user_id,
task_id=task_id,
date=datetime.date(2017, 9, 23),
duration=7200
)
ts3 = TimeSpent.create(
person_id=user_id,
task_id=task_id,
date=datetime.date(2017, 9, 24),
duration=7200
)
time_spents = self.get(
"/data/time-spents?task_id=%s" % task_id
)
self.assertEqual(
time_spents["total"],
sum([ts.duration for ts in [ts1, ts2, ts3]]))
self.assertEqual(len(time_spents[str(user_id)]), 1)
self.assertEqual(len(time_spents[str(person_id)]), 2)
"""
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_with_relations(task_id)
self.assertEqual(len(task["assignees"]), 0)
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)
comments_service.new_comment(
self.task.id, self.task_status.id, self.person.id, "first comment"
)
comments_service.new_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_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_update_task(self):
done_status = tasks_service.get_done_status()
tasks_service.update_task(
self.task.id, {"task_status_id": done_status["id"]}
)
self.assertEqual(str(self.task.task_status_id), done_status["id"])
self.assertIsNotNone(self.task.end_date)
self.assertLess(self.task.end_date, datetime.datetime.now())
def test_remove_task(self):
self.working_file.delete()
self.output_file.delete()
deletion_service.remove_task(self.task_id)
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, self.task_id
)
def test_remove_tasks(self):
self.working_file.delete()
self.output_file.delete()
task_id = str(self.task_id)
task2_id = str(self.generate_fixture_task("main 2").id)
task_ids = [task_id, task2_id]
deletion_service.remove_tasks(self.project_id, task_ids)
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, task_id
)
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, task2_id
)
def test_remove_task_force(self):
comments_service.new_comment(
self.task.id, self.task_status.id, self.person.id, "first comment"
)
TimeSpent.create(
person_id=self.person.id,
task_id=self.task.id,
date=datetime.date(2017, 9, 23),
duration=3600,
)
deletion_service.remove_task(self.task_id, force=True)
self.assertRaises(
TaskNotFoundException, tasks_service.get_task, self.task_id
)
def test_delete_all_task_types(self):
self.generate_fixture_project_standard()
self.generate_fixture_asset_standard()
task_1_id = str(self.task.id)
task_2_id = str(self.generate_fixture_task(name="second task").id)
task_3_id = str(self.shot_task.id)
task_4_id = str(self.generate_fixture_task_standard().id)
deletion_service.remove_tasks_for_project_and_task_type(
self.project.id, self.task_type.id
)
self.assertIsNone(Task.get(task_1_id))
self.assertIsNone(Task.get(task_2_id))
self.assertIsNotNone(Task.get(task_3_id))
self.assertIsNotNone(Task.get(task_4_id))
def test_get_comment_mentions(self):
mentions = comments_service.get_comment_mentions(
self.task_id, "Test @Emma Doe"
)
self.assertEqual(len(mentions), 0)
mentions = comments_service.get_comment_mentions(
self.task_id, "Test @John Doe"
)
self.assertEqual(mentions[0], self.person)
def test_get_comments(self):
self.generate_fixture_user_client()
self.generate_fixture_comment()
self.generate_fixture_comment()
self.generate_fixture_comment(person=self.user_client)
self.generate_fixture_comment()
comments = tasks_service.get_comments(self.task_id, is_manager=True)
self.assertEqual(len(comments), 4)
comments = tasks_service.get_comments(self.task_id, is_manager=False)
self.assertEqual(len(comments), 3)
comments = tasks_service.get_comments(self.task_id, is_client=True)
self.assertEqual(len(comments), 1)
def test_new_comment(self):
comment = comments_service.new_comment(
self.task_id, self.task_status.id, self.person.id, "Test @John Doe"
)
self.assertEqual(comment["mentions"][0], str(self.person.id))
def test_get_full_task(self):
task = tasks_service.get_full_task(self.task.id)
self.assertEqual(task["project"]["name"], self.project.name)
self.assertEqual(task["assigner"]["id"], str(self.assigner.id))
self.assertEqual(task["persons"][0]["id"], str(self.person.id))
self.assertEqual(task["task_status"]["id"], str(self.task_status.id))
self.assertEqual(task["task_type"]["id"], str(self.task_type.id))
task = tasks_service.get_full_task(self.shot_task.id)
self.assertEqual(task["sequence"]["id"], str(self.sequence.id))
def test_get_next_position(self):
self.generate_fixture_preview_file(revision=1)
self.generate_fixture_preview_file(revision=2)
self.generate_fixture_preview_file(revision=2, name="second")
task_id = self.task.id
position = tasks_service.get_next_position(task_id, 2)
self.assertEqual(position, 3)
def test_update_preview_file_position(self):
self.generate_fixture_preview_file(revision=1)
self.generate_fixture_preview_file(revision=2)
preview_file = self.generate_fixture_preview_file(
revision=2, name="second"
)
preview_file_id = str(preview_file.id)
self.generate_fixture_preview_file(revision=2, name="third")
preview_files_service.update_preview_file_position(preview_file_id, 1)
preview_files = PreviewFile.query.filter_by(
task_id=self.task_id, revision=2
).order_by(PreviewFile.position)
for (i, preview_file) in enumerate(preview_files):
self.assertEqual(preview_file.position, i + 1)
self.assertEqual(str(preview_files[0].id), preview_file_id)
preview_files_service.update_preview_file_position(preview_file_id, 3)
preview_files = PreviewFile.query.filter_by(
task_id=self.task_id, revision=2
).order_by(PreviewFile.position)
for (i, preview_file) in enumerate(preview_files):
self.assertEqual(preview_file.position, i + 1)
self.assertEqual(str(preview_files[2].id), preview_file_id)
class ApiDBTestCase(ApiTestCase):
def setUp(self):
"""
Reset database before each test.
"""
super(ApiDBTestCase, self).setUp()
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
dbhelpers.create_all()
self.log_in()
def log_in(self):
self.generate_fixture_user()
self.post("auth/login", {
"email": self.user.email,
"password": "******"
}, 200)
def tearDown(self):
"""
Delete database after each test.
"""
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
def generate_data(self, cls, number, **kwargs):
"""
Generate random data for a given data model.
"""
mixer.init_app(self.flask_app)
return mixer.cycle(number).blend(cls, id=fields.gen_uuid, **kwargs)
def generate_fixture_project_status(self):
self.open_status = ProjectStatus(name="open", color="#FFFFFF")
self.open_status.save()
def generate_fixture_project_closed_status(self):
self.closed_status = ProjectStatus(name="closed", color="#FFFFFF")
self.closed_status.save()
def generate_fixture_project(self):
self.project = Project(name="Cosmos Landromat",
project_status_id=self.open_status.id)
self.project.save()
self.project.update(
{"file_tree": file_tree.get_tree_from_file("simple")})
def generate_fixture_project_closed(self):
self.project_closed = Project(name="Old Project",
project_status_id=self.closed_status.id)
self.project_closed.save()
def generate_fixture_project_standard(self):
self.project_standard = Project(name="Big Buck Bunny",
project_status_id=self.open_status.id)
self.project_standard.save()
self.project_standard.update(
{"file_tree": file_tree.get_tree_from_file("standard")})
def generate_fixture_entity(self):
self.entity = Entity(name="Tree",
description="Description Tree",
project_id=self.project.id,
entity_type_id=self.entity_type.id)
self.entity.save()
def generate_fixture_entity_standard(self):
self.entity_standard = Entity(name="Car",
project_id=self.project_standard.id,
entity_type_id=self.entity_type.id)
self.entity_standard.save()
def generate_fixture_sequence(self):
if hasattr(self, "episode"):
episode_id = self.episode.id
else:
episode_id = None
self.sequence = Entity(name="S01",
project_id=self.project.id,
entity_type_id=self.sequence_type.id,
parent_id=episode_id)
self.sequence.save()
def generate_fixture_sequence_standard(self):
self.sequence_standard = Entity(name="S01",
project_id=self.project_standard.id,
entity_type_id=self.sequence_type.id)
self.sequence_standard.save()
def generate_fixture_episode(self):
self.episode = Entity(name="E01",
project_id=self.project.id,
entity_type_id=self.episode_type.id)
self.episode.save()
def generate_fixture_shot(self):
self.shot = Entity(name="P01",
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence.id)
self.shot.save()
self.shot_noseq = Entity(name="P01NOSEQ",
project_id=self.project.id,
entity_type_id=self.shot_type.id)
self.shot_noseq.save()
def generate_fixture_shot_standard(self):
self.shot_standard = Entity(name="P01",
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id)
self.shot_standard.save()
def generate_fixture_user(self):
self.user = Person(first_name="John",
last_name="Did",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
self.user.save()
def generate_fixture_person(self):
self.person = Person(first_name="John",
last_name="Doe",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
self.person.save()
def generate_fixture_entity_type(self):
self.entity_type = EntityType(name="Props")
self.entity_type.save()
self.shot_type = EntityType(name="Shot")
self.shot_type.save()
self.sequence_type = EntityType(name="Sequence")
self.sequence_type.save()
self.episode_type = EntityType(name="Episode")
self.episode_type.save()
def generate_fixture_department(self):
self.department = Department(name="Modeling", color="#FFFFFF")
self.department.save()
self.department_animation = Department(name="Animation",
color="#FFFFFF")
self.department_animation.save()
def generate_fixture_task_type(self):
self.task_type = TaskType(name="Shaders",
color="#FFFFFF",
department_id=self.department.id)
self.task_type.save()
self.task_type_animation = TaskType(
name="Animation",
color="#FFFFFF",
department_id=self.department_animation.id)
self.task_type_animation.save()
def generate_fixture_task_status(self):
self.task_status = TaskStatus(name="Open",
short_name="opn",
color="#FFFFFF")
self.task_status.save()
def generate_fixture_task_status_wip(self):
self.task_status_wip = TaskStatus(name="WIP",
short_name="wip",
color="#FFFFFF")
self.task_status_wip.save()
def generate_fixture_task_status_to_review(self):
self.task_status_to_review = TaskStatus(name="To review",
short_name="pndng",
color="#FFFFFF")
self.task_status_to_review.save()
def generate_fixture_assigner(self):
self.assigner = Person(first_name="Ema", last_name="Peel")
self.assigner.save()
def generate_fixture_task(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task = Task(name="Super modeling",
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.entity.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task.save()
def generate_fixture_task_standard(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task_standard = Task(name="Super modeling",
project_id=self.project_standard.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.entity_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task_standard.save()
def generate_fixture_shot_task(self):
self.shot_task = Task(
name="Super animation",
project_id=self.project.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
self.shot_task.save()
def generate_fixture_shot_task_standard(self):
self.shot_task_standard = Task(
name="Super animation",
project_id=self.project_standard.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id)
self.shot_task_standard.save()
def generate_fixture_file_status(self):
self.file_status = FileStatus(name="To review", color="#FFFFFF")
self.file_status.save()
def generate_fixture_working_file(self):
self.working_file = WorkingFile(name="S01_P01_modeling",
comment="",
revision=1,
task_id=self.task.id,
entity_id=self.entity.id,
person_id=self.person.id)
self.working_file.save()
def generate_fixture_shot_working_file(self):
self.working_file = WorkingFile(name="S01_P01_animation",
comment="",
revision=1,
task_id=self.task.id,
entity_id=self.shot.id,
person_id=self.person.id)
self.working_file.save()
def generate_fixture_output_file(self):
self.output_file = OutputFile(comment="",
revision=1,
task_id=self.task.id,
entity_id=self.entity.id,
person_id=self.person.id,
file_status_id=self.file_status.id)
self.output_file.save()
def get_fixture_file_path(self, relative_path):
current_path = os.getcwd()
file_path_fixture = os.path.join(current_path, "test", "fixtures",
relative_path)
return file_path_fixture
def import_row(self, row):
project_name = row["Project"]
department_name = row["Department"]
task_type_name = row["Task Type"]
task_status_name = row["Task Status"]
entity_type_name = row["Asset Type"]
entity_name = row["Asset"]
episode_name = row["Episode"]
sequence_name = row["Sequence"]
shot_name = row["Shot"]
name = row["Name"]
assigner_name = row["Assigner"]
assignee_name = row["Assignee"]
duration = int(row["Duration"]) * 3600
estimation = int(row["Estimation"]) * 3600
start_date = self.normalize_date(row["Start Date"])
real_start_date = self.normalize_date(row["Real Start Date"])
due_date = self.normalize_date(row["Due Date"])
end_date = self.normalize_date(row["End Date"])
self.add_to_cache_if_absent(self.task_statuses,
tasks_service.get_or_create_status,
task_status_name)
task_status_id = self.get_id_from_cache(self.task_statuses,
task_status_name)
self.add_to_cache_if_absent(self.departments,
tasks_service.get_or_create_department,
department_name)
department_id = self.get_id_from_cache(self.departments,
department_name)
task_type_key = "%s-%s" % (department_id, task_type_name)
if task_type_key not in self.task_types:
department = self.departments[department_name]
self.task_types[task_type_key] = \
tasks_service.get_or_create_task_type(
department,
task_type_name
)
task_type_id = self.get_id_from_cache(self.task_types, task_type_key)
project_id = self.projects[project_name].id
assigner_id = self.persons[assigner_name].id
assignee = self.persons.get(assignee_name, None)
if len(shot_name) > 0:
episode_id = self.episodes[str(project_id) + episode_name]["id"]
sequence_id = self.sequences[str(project_id) + str(episode_id) +
sequence_name]["id"]
entity_id = self.shots[str(project_id) + str(sequence_id) +
shot_name]["id"]
else:
entity_type_id = self.entity_types[entity_type_name].id
entity_id = self.entities[str(project_id) + str(entity_type_id) +
entity_name].id
task = Task.create(name=name,
project_id=project_id,
task_type_id=task_type_id,
entity_id=entity_id,
task_status_id=task_status_id,
assigner_id=assigner_id,
duration=duration,
estimation=estimation,
start_date=start_date,
end_date=end_date,
real_start_date=real_start_date,
due_date=due_date)
if assignee is not None:
task.assignees.append(assignee)
task.save()
return task
def reset_tasks_data(project_id):
for task in Task.get_all_by(project_id=project_id):
reset_task_data(str(task.id))
