zou 0.19.14__py3-none-any.whl → 0.20.11__py3-none-any.whl

zou/app/services/sync_service.py

@@ -42,10 +42,11 @@ from zou.app.models.task import Task
 from zou.app.models.task_status import TaskStatus
 from zou.app.models.task_type import TaskType
 from zou.app.models.time_spent import TimeSpent
+from zou.app.models.studio import Studio
 
 from zou.app.services import deletion_service, tasks_service, projects_service
 from zou.app.stores import file_store
-from zou.app.utils import events
+from zou.app.utils import events, date_helpers
 from zou.app import app, config
 
 
@@ -102,6 +103,7 @@ event_name_model_map = {
     "subscription": Subscription,
     "search-filter": SearchFilter,
     "search-filter-group": SearchFilterGroup,
+    "studio": Studio,
     "task": Task,
     "task-status": TaskStatus,
     "task-type": TaskType,
@@ -140,6 +142,7 @@ event_name_model_path_map = {
     "search-filter": "search-filters",
     "search-filter-group": "search-filter-groups",
     "subscription": "subscriptions",
+    "studio": "studios",
     "task": "tasks",
     "task-status": "task-status",
     "task-type": "task-types",
@@ -169,14 +172,15 @@ project_events = [
 ]
 
 main_events = [
-    "person",
-    "organisation",
-    "project-status",
+    "studio",
     "department",
     "task-type",
     "task-status",
     "custom-action",
+    "organisation",
+    "project-status",
     "asset-type",
+    "person",
     "project",
 ]
 
@@ -319,14 +323,14 @@ def run_other_sync(project=None, with_events=False):
         sync_entries("events", ApiEvent, project=project)
 
 
-def run_last_events_sync(minutes=0, page_size=300):
+def run_last_events_sync(minutes=0, limit=300):
     """
     Retrieve last events from source instance and import related data and
     action.
     """
-    path = "events/last?page_size=%s" % page_size
+    path = "events/last?limit=%s" % limit
     if minutes > 0:
-        now = datetime.datetime.utcnow()
+        now = date_helpers.get_utc_now_datetime()
         min_before = now - datetime.timedelta(minutes=minutes)
         after = min_before.strftime("%Y-%m-%dT%H:%M:%S")
         path += "&before=%s" % now.strftime("%Y-%m-%dT%H:%M:%S")
@@ -342,14 +346,14 @@ def run_last_events_sync(minutes=0, page_size=300):
                 pass
 
 
-def run_last_events_files(minutes=0, page_size=50):
+def run_last_events_files(minutes=0, limit=50):
     """
     Retrieve last events from source instance and import related data and
     action.
     """
-    path = "events/last?only_files=true&page_size=%s" % page_size
+    path = "events/last?only_files=true&limit=%s" % limit
     if minutes > 0:
-        now = datetime.datetime.utcnow()
+        now = date_helpers.get_utc_now_datetime()
         min_before = now - datetime.timedelta(minutes=minutes)
         after = min_before.strftime("%Y-%m-%dT%H:%M:%S")
         path += "&before=%s" % now.strftime("%Y-%m-%dT%H:%M:%S")
@@ -404,35 +408,35 @@ def sync_entries(model_name, model, project=None):
     """
     instances = []
 
-    if model_name in ["organisations", "persons"]:
-        path = model_name + "?relations=true"
-        if model_name == "persons":
-            path += "&with_pass_hash=true"
-        instances = gazu.client.fetch_all(path)
-        model.create_from_import_list(instances)
-    elif project:
+    page = 1
+    init = True
+    results = {"nb_pages": 2}
+    params = {
+        "relations": "true",
+    }
+    if model_name == "persons":
+        params["with_pass_hash"] = "true"
+    if project is not None and model_name in [
+        "projects",
+        "search-filters",
+        "search-filter-groups",
+    ]:
         project = gazu.project.get_project_by_name(project)
         if model_name == "projects":
-            instances = [gazu.client.fetch_one(model_name, project.get("id"))]
+            params = {"id": project["id"]}
         elif model_name in ["search-filters", "search-filter-groups"]:
-            instances = gazu.client.fetch_all(
-                model_name, params=dict(project_id=project.get("id"))
-            )
-        else:
-            instances = gazu.client.fetch_all(model_name)
-        model.create_from_import_list(instances)
-    else:
-        page = 1
-        init = True
-        results = {"nb_pages": 2}
-        while init or results["nb_pages"] >= page:
-            results = gazu.client.fetch_all(
-                "%s?relations=true&page=%d" % (model_name, page)
-            )
-            instances += results["data"]
-            page += 1
-            init = False
-            model.create_from_import_list(results["data"])
+            params = {"project_id": project["id"]}
+    while init or results["nb_pages"] >= page:
+        params["page"] = page
+        results = gazu.client.fetch_all(model_name, params=params)
+        if model_name == "task-status" and results["data"]:
+            results["data"] = [
+                r for r in results["data"] if not r["for_concept"]
+            ]
+        instances += results["data"]
+        page += 1
+        init = False
+        model.create_from_import_list(results["data"])
 
     logger.info("%s %s synced." % (len(instances), model_name))
 
@@ -1144,19 +1148,19 @@ def download_preview_background_from_another_instance(
     """
     Download all files link to preview background file entry.
     """
-    extension = preview_background.extension
-
     preview_background_file_id = str(preview_background.id)
     for prefix in [
         "thumbnails",
         "preview-backgrounds",
     ]:
+        extension = (
+            "png" if prefix == "thumbnails" else preview_background.extension
+        )
         if prefix == "preview-backgrounds":
             path = f"/pictures/preview-background-files/{preview_background_file_id}.{extension}"
         elif prefix == "thumbnails":
             path = f"/pictures/thumbnails/preview-background-files/{preview_background_file_id}.png"
 
-        extension = "png" if prefix == "thumbnails" else extension
         file_path = f"/tmp/{prefix}-{preview_background_file_id}.{extension}"
         download_file_from_another_instance(
             path,
@@ -1169,9 +1173,9 @@ def download_preview_background_from_another_instance(
             force,
             dict_errors,
         )
-        logger.info(
-            f"{index:0{len(str(total))}}/{total} Preview background file {preview_background_file_id} processed."
-        )
+    logger.info(
+        f"{index:0{len(str(total))}}/{total} Preview background file {preview_background_file_id} processed."
+    )
 
 
 def download_attachment_files_from_another_instance(

zou/app/services/tasks_service.py

@@ -1,9 +1,9 @@
 import collections
-import datetime
 import uuid
 
 from sqlalchemy.exc import StatementError, IntegrityError, DataError
 from sqlalchemy.sql import func
+from sqlalchemy.sql.expression import case
 from sqlalchemy.orm import aliased
 
 from zou.app import app, db
@@ -29,8 +29,15 @@ from zou.app.models.task import Task
 from zou.app.models.task_type import TaskType
 from zou.app.models.task_status import TaskStatus
 from zou.app.models.time_spent import TimeSpent
-
-from zou.app.utils import cache, fields, query as query_utils, permissions
+from zou.app.models.studio import Studio
+
+from zou.app.utils import (
+    cache,
+    fields,
+    query as query_utils,
+    permissions,
+    date_helpers,
+)
 
 
 from zou.app.services.exception import (
@@ -41,6 +48,7 @@ from zou.app.services.exception import (
     TaskStatusNotFoundException,
     TaskTypeNotFoundException,
     DepartmentNotFoundException,
+    StudioNotFoundException,
     WrongDateFormatException,
     TimeSpentNotFoundException,
 )
@@ -75,16 +83,20 @@ def clear_department_cache(department_id):
     cache.cache.delete_memoized(get_departments)
 
 
+def clear_studio_cache(studio_id):
+    cache.cache.delete_memoized(get_studio, studio_id)
+    cache.cache.delete_memoized(get_studios)
+
+
 def clear_task_cache(task_id):
     cache.cache.delete_memoized(get_task, task_id)
     cache.cache.delete_memoized(get_task, task_id, True)
-    cache.cache.delete_memoized(get_task_with_relations, task_id)
 
 
 @cache.memoize_function(120)
 def clear_comment_cache(comment_id):
     cache.cache.delete_memoized(get_comment, comment_id)
-    cache.cache.delete_memoized(get_comment_with_relations, comment_id)
+    cache.cache.delete_memoized(get_comment, comment_id, True)
 
 
 @cache.memoize_function(120)
@@ -92,6 +104,11 @@ def get_departments():
     return fields.serialize_models(Department.get_all())
 
 
+@cache.memoize_function(120)
+def get_studios():
+    return fields.serialize_models(Studio.get_all())
+
+
 @cache.memoize_function(120)
 def get_task_types():
     return fields.serialize_models(TaskType.get_all())
@@ -154,6 +171,22 @@ def get_department(department_id):
     return department.serialize()
 
 
+@cache.memoize_function(120)
+def get_studio(studio_id):
+    """
+    Get studio matching given id as a dictionary.
+    """
+    try:
+        studio = Studio.get(studio_id)
+    except StatementError:
+        raise StudioNotFoundException
+
+    if studio is None:
+        raise StudioNotFoundException
+
+    return studio.serialize()
+
+
 def get_department_from_task_type(task_type_id):
     """
     Get department of given task type as dictionary
@@ -216,14 +249,6 @@ def get_task(task_id, relations=False):
     return get_task_raw(task_id).serialize(relations=relations)
 
 
-@cache.memoize_function(120)
-def get_task_with_relations(task_id):
-    """
-    Get task matching given id as a dictionary.
-    """
-    return get_task_raw(task_id).serialize(relations=True)
-
-
 def get_task_by_shotgun_id(shotgun_id):
     """
     Get task matching given shotgun id as a dictionary.
@@ -362,7 +387,7 @@ def _convert_rows_to_detailed_tasks(rows, relations=False):
             entity_name,
         ) = entry
 
-        task = get_task_with_relations(str(task_object.id))
+        task = get_task(str(task_object.id), relations=relations)
         task["project_name"] = project_name
         task["task_type_name"] = task_type_name
         task["task_status_name"] = task_status_name
@@ -740,21 +765,11 @@ def get_comment_raw(comment_id):
 
 
 @cache.memoize_function(120)
-def get_comment(comment_id):
+def get_comment(comment_id, relations=False):
     """
     Return comment matching give id as a dict.
     """
-    comment = get_comment_raw(comment_id)
-    return comment.serialize()
-
-
-@cache.memoize_function(120)
-def get_comment_with_relations(comment_id):
-    """
-    Return comment matching give id as a dict with joins information.
-    """
-    comment = get_comment_raw(comment_id)
-    return comment.serialize(relations=True)
+    return get_comment_raw(comment_id).serialize(relations=relations)
 
 
 def get_comment_by_preview_file_id(preview_file_id):
@@ -951,7 +966,7 @@ def get_person_tasks(person_id, projects, is_done=None):
                 except EpisodeNotFoundException:
                     episode_name = "MP"
 
-        task_dict = get_task_with_relations(str(task.id))
+        task_dict = get_task(str(task.id), relations=True)
         if entity_type_name == "Sequence" and entity_parent_id is not None:
             episode_id = entity_parent_id
             episode = shots_service.get_episode(episode_id)
@@ -1048,7 +1063,7 @@ def get_person_tasks_to_check(project_ids=None, department_ids=None):
     else:
         query = query.filter(user_service.build_open_project_filter())
 
-    if department_ids is not None:
+    if department_ids:
         query = query.filter(TaskType.department_id.in_(department_ids))
     tasks = []
     for (
@@ -1083,7 +1098,7 @@ def get_person_tasks_to_check(project_ids=None, department_ids=None):
         if episode_id is None:
             episode_id = entity_source_id
 
-        task_dict = get_task_with_relations(str(task.id))
+        task_dict = get_task(str(task.id), relations=True)
         if entity_type_name == "Sequence" and entity_parent_id is not None:
             episode_id = entity_parent_id
             episode = shots_service.get_episode(episode_id)
@@ -1261,7 +1276,10 @@ def update_task(task_id, data):
     task = get_task_raw(task_id)
 
     if is_finished(task, data):
-        data["end_date"] = datetime.datetime.utcnow()
+        data["end_date"] = date_helpers.get_utc_now_datetime()
+
+    if is_done(task, data):
+        data["done_date"] = date_helpers.get_utc_now_datetime()
 
     task.update(data)
     clear_task_cache(task_id)
@@ -1456,7 +1474,7 @@ def delete_time_spent(task_id, person_id, date):
 
 def is_finished(task, data):
     """
-    Return True if task status is set to done.
+    Return True if task status is set to feedback request.
     """
     if "task_status_id" in data:
         task_status = get_task_status_raw(task.task_status_id)
@@ -1469,6 +1487,18 @@ def is_finished(task, data):
         return False
 
 
+def is_done(task, data):
+    """
+    Return True if task status is set to done.
+    """
+    if "task_status_id" in data:
+        task_status = get_task_status_raw(task.task_status_id)
+        new_task_status = get_task_status_raw(data["task_status_id"])
+        return new_task_status.id != task_status.id and new_task_status.is_done
+    else:
+        return False
+
+
 def clear_assignation(task_id, person_id=None):
     """
     Clear task assignation and emit a *task:unassign* event.
@@ -1616,20 +1646,14 @@ def update_preview_file_info(preview_file):
         project = projects_service.get_project(task.project_id)
 
         if project["is_set_preview_automated"]:
-            entity_id = str(task.entity_id)
             entity = entities_service.update_entity_preview(
-                entity_id,
+                task.entity_id,
                 preview_file["id"],
             )
-            assets_service.clear_asset_cache(entity_id)
-            edits_service.clear_edit_cache(entity_id)
-            shots_service.clear_shot_cache(entity_id)
-            shots_service.clear_episode_cache(entity_id)
-            shots_service.clear_sequence_cache(entity_id)
     return entity
 
 
-def get_comments_for_project(project_id, page=0):
+def get_comments_for_project(project_id, page=0, limit=None):
     """
     Return all comments for given project.
     """
@@ -1638,7 +1662,9 @@ def get_comments_for_project(project_id, page=0):
         .filter(Task.project_id == project_id)
         .order_by(Comment.updated_at.desc())
     )
-    return query_utils.get_paginated_results(query, page, relations=True)
+    return query_utils.get_paginated_results(
+        query, page, limit, relations=True
+    )
 
 
 def get_time_spents_for_project(project_id, page=0):
@@ -1649,18 +1675,38 @@ def get_time_spents_for_project(project_id, page=0):
     return query_utils.get_paginated_results(query, page)
 
 
-def get_tasks_for_project(project_id, page=0):
+def get_tasks_for_project(
+    project_id, page=0, task_type_id=None, episode_id=None
+):
     """
     Return all tasks for given project.
     """
     query = Task.query.filter(Task.project_id == project_id).order_by(
         Task.updated_at.desc()
     )
+    if task_type_id is not None:
+        query = query.filter(Task.task_type_id == task_type_id)
+    if episode_id is not None:
+        Sequence = aliased(Entity, name="sequence")
+        query = (
+            query.join(Entity, Entity.id == Task.entity_id)
+            .join(Sequence, Sequence.id == Entity.parent_id)
+            .filter(Sequence.parent_id == episode_id)
+        )
+
+        if permissions.has_vendor_permissions():
+            query = query.filter(user_service.build_assignee_filter())
+        elif not permissions.has_admin_permissions():
+            query = query.join(Project).filter(
+                user_service.build_related_projects_filter()
+            )
+        return query
+
     return query_utils.get_paginated_results(query, page, relations=True)
 
 
 def get_full_task(task_id, user_id):
-    task = get_task_with_relations(task_id)
+    task = get_task(task_id, relations=True)
     task_type = get_task_type(task["task_type_id"])
     project = projects_service.get_project(task["project_id"])
     task_status = get_task_status(task["task_status_id"])
@@ -1724,6 +1770,7 @@ def reset_task_data(task_id):
     real_start_date = None
     last_comment_date = None
     end_date = None
+    done_date = None
     entity = entities_service.get_entity(task.entity_id)
     task_status_id = get_default_status(
         for_concept=entity["entity_type_id"]
@@ -1736,6 +1783,7 @@ def reset_task_data(task_id):
         .add_columns(
             TaskStatus.is_retake,
             TaskStatus.is_feedback_request,
+            TaskStatus.is_done,
             TaskStatus.short_name,
         )
         .all()
@@ -1746,6 +1794,7 @@ def reset_task_data(task_id):
         comment,
         task_status_is_retake,
         task_status_is_feedback_request,
+        task_status_is_done,
         task_status_short_name,
     ) in comments:
         if task_status_is_retake and not previous_is_retake:
@@ -1758,6 +1807,11 @@ def reset_task_data(task_id):
         if task_status_is_feedback_request:
             end_date = comment.created_at
 
+        print("ok", task_status_is_done)
+        if task_status_is_done:
+            done_date = comment.created_at
+            print(done_date)
+
         task_status_id = comment.task_status_id
         last_comment_date = comment.created_at
 
@@ -1773,12 +1827,13 @@ def reset_task_data(task_id):
             "real_start_date": real_start_date,
             "last_comment_date": last_comment_date,
             "end_date": end_date,
+            "done_date": done_date,
             "task_status_id": task_status_id,
         }
     )
     project_id = str(task.project_id)
     events.emit("task:update", {"task_id": task.id}, project_id)
-    return task.serialize()
+    return task.serialize(relations=True)
 
 
 def get_persons_tasks_dates():
@@ -1907,14 +1962,20 @@ def get_open_tasks(
         query_stats = query_stats.filter(TaskStatus.id == task_status_id)
 
     if person_id is not None:
-        query = query.filter(Task.assignees.any(id=person_id))
-        query_stats = query_stats.filter(Task.assignees.any(id=person_id))
+        if person_id == "unassigned":
+            query = query.filter(Task.assignees == None)
+            query_stats = query_stats.filter(Task.assignees == None)
+        else:
+            query = query.filter(Task.assignees.any(id=person_id))
+            query_stats = query_stats.filter(Task.assignees.any(id=person_id))
 
     if start_date is not None:
+        start_date = func.cast(start_date, Task.start_date.type)
         query = query.filter(Task.start_date >= start_date)
         query_stats = query_stats.filter(Task.start_date >= start_date)
 
     if due_date is not None:
+        due_date = func.cast(due_date, Task.due_date.type)
         query = query.filter(Task.due_date <= due_date)
         query_stats = query_stats.filter(Task.due_date <= due_date)
 
@@ -1972,7 +2033,7 @@ def get_open_tasks(
                 except EpisodeNotFoundException:
                     episode_name = "MP"
 
-        task_dict = get_task_with_relations(str(task.id))
+        task_dict = get_task(str(task.id), relations=True)
         if entity_type_name == "Sequence" and entity_parent_id is not None:
             episode_id = entity_parent_id
             episode = shots_service.get_episode(episode_id)
@@ -1998,6 +2059,7 @@ def get_open_tasks(
                 "duration": task.duration,
                 "start_date": fields.serialize_value(task.start_date),
                 "due_date": fields.serialize_value(task.due_date),
+                "done_date": fields.serialize_value(task.done_date),
                 "type_name": task_type_name,
                 "task_type_for_entity": task_type_for_entity,
                 "status_name": task_status_name,
@@ -2043,3 +2105,80 @@ def get_open_tasks(
             "page": page or 1,
         }
     return result
+
+
+def get_open_tasks_stats():
+    """
+    Return the amount of tasks, done tasks, estimation, and duration for each
+    status in open projects. Aggregate the amounts for each project.
+    """
+    Sequence = aliased(Entity, name="sequence")
+    Episode = aliased(Entity, name="episode")
+
+    from zou.app import db
+
+    query_stats = (
+        db.session.query(
+            func.count().label("amount"),
+            func.count(case({TaskStatus.is_done: Task.id})).label(
+                "amount_done"
+            ),
+            func.sum(Task.duration).label("total_duration"),
+            func.sum(Task.estimation).label("total_estimation"),
+        )
+        .join(TaskType, Task.task_type_id == TaskType.id)
+        .join(TaskStatus, Task.task_status_id == TaskStatus.id)
+        .join(Entity, Entity.id == Task.entity_id)
+        .join(EntityType, EntityType.id == Entity.entity_type_id)
+        .join(Project, Project.id == Task.project_id)
+        .join(ProjectStatus, ProjectStatus.id == Project.project_status_id)
+        .filter(TaskType.for_entity != "Concept")
+        .group_by(Project.id, TaskType.id, TaskStatus.id)
+        .add_columns(
+            Project.id.label("project_id"),
+            TaskType.id.label("task_type_id"),
+            TaskStatus.id.label("task_status_id"),
+        )
+    )
+
+    if permissions.has_admin_permissions():
+        query_stats = query_stats.filter(ProjectStatus.name == "Open")
+    else:
+        query_stats = query_stats.filter(
+            user_service.build_related_projects_filter()
+        )
+
+    stats_status = query_stats.all()
+
+    statuses_stats = [
+        {
+            "task_status_id": stat.task_status_id,
+            "task_type_id": stat.task_type_id,
+            "project_id": stat.project_id,
+            "amount": stat.amount,
+            "amount_done": stat.amount_done,
+            "total_duration": stat.total_duration,
+            "total_estimation": stat.total_estimation,
+        }
+        for stat in stats_status
+    ]
+
+    stats_map = {}
+    for stat in statuses_stats:
+        project_id = stat["project_id"]
+        if project_id not in stats_map:
+            stats_map[project_id] = {
+                "amount": 0,
+                "amount_done": 0,
+                "total_duration": 0,
+                "total_estimation": 0,
+                "task_types": [],
+            }
+        project_stats = stats_map[project_id]
+        project_stats["amount"] += stat["amount"]
+        project_stats["amount_done"] += stat["amount_done"]
+        project_stats["total_duration"] += stat["total_duration"]
+        project_stats["total_estimation"] += stat["total_estimation"]
+        project_stats["task_types"].append(stat)
+
+    return stats_map